Namespaces
namespace	details

Classes
class	ChainAdapter

class	ConcatAdapter

class	Defer

class	DynamicLibrary

class	EnumerateAdapter

class	FastPimpl
	Implements pimpl idiom without dynamic memory allocation. More...

class	FilterAdapter

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

class	InspectAdapter

class	JoinAdapter

class	MapAdapter

class	ReverseAdapter

class	SkipAdapter

class	SkipWhileAdapter

class	SlideAdapter

class	SlideView

class	StepByAdapter

class	StrideAdapter

struct	StringEqual
	Transparent equality comparator for string types. More...

struct	StringHash
	Transparent hash functor for string types. More...

class	TakeAdapter

class	TakeWhileAdapter

class	ZipAdapter

Concepts
concept	ArithmeticTrait

concept	UniqueTypes

concept	IteratorLike
	Concept for types that can be used as base iterators in adapters.

concept	BidirectionalIteratorLike
	Concept for bidirectional iterators that support decrement operations.

concept	PredicateFor
	Concept for predicate functions that can be applied to iterator values.

concept	TransformFor
	Concept for transformation functions that can be applied to iterator values.

concept	InspectorFor
	Concept for inspection functions that observe but don't modify values.

concept	ActionFor
	Concept for action functions that process values.

concept	FolderFor
	Concept for folder functions that accumulate values.

concept	FilterAdapterRequirements
	Concept to validate FilterAdapter requirements.

concept	MapAdapterRequirements
	Concept to validate MapAdapter requirements.

concept	TakeAdapterRequirements
	Concept to validate TakeAdapter requirements.

concept	SkipAdapterRequirements
	Concept to validate SkipAdapter requirements.

concept	TakeWhileAdapterRequirements
	Concept to validate TakeWhileAdapter requirements.

concept	SkipWhileAdapterRequirements
	Concept to validate SkipWhileAdapter requirements.

concept	EnumerateAdapterRequirements
	Concept to validate EnumerateAdapter requirements.

concept	InspectAdapterRequirements
	Concept to validate InspectAdapter requirements.

concept	StepByAdapterRequirements
	Concept to validate StepByAdapter requirements.

concept	ChainAdapterRequirements
	Concept to validate ChainAdapter requirements.

concept	ReverseAdapterRequirements
	Concept to validate ReverseAdapter requirements.

concept	JoinAdapterRequirements
	Concept to validate JoinAdapter requirements.

concept	SlideAdapterRequirements
	Concept to validate SlideAdapter requirements.

concept	ConcatAdapterRequirements
	Concept to validate ConcatAdapter requirements.

concept	StrideAdapterRequirements
	Concept to validate StrideAdapter requirements.

concept	ZipAdapterRequirements
	Concept to validate ZipAdapter requirements.

Enumerations
enum class	DynamicLibraryError : uint8_t { FileNotFound , LoadFailed , SymbolNotFound , InvalidHandle , AlreadyLoaded , NotLoaded , PlatformError }
	Error codes for dynamic library operations. More...

enum class	FileError : uint8_t { kCouldNotOpen , kReadError }

Functions
constexpr std::string_view	DynamicLibraryErrorToString (DynamicLibraryError error) noexcept
	Gets a human-readable description for a DynamicLibraryError.

auto	FromPath (const std::filesystem::path &path) -> std::expected< DynamicLibrary, DynamicLibraryError >

constexpr std::string_view	FileErrorToString (FileError error) noexcept
	Converts FileError to a human-readable string.

auto	ReadFileToString (std::string_view filepath) -> std::expected< std::string, FileError >
	Reads the entire contents of a file into a string.

auto	ReadFileToString (const std::filesystem::path &filepath) -> std::expected< std::string, FileError >
	Reads the entire contents of a file into a string.

constexpr std::string_view	GetFileName (std::string_view path)
	Extracts the file name from a given path.

static constexpr std::string_view	GetFileExtension (std::string_view path)
	Extracts the file extension from a given path.

template<std::ranges::range R, typename Pred > requires FilterAdapterRequirements<std::ranges::iterator_t<R>, Pred>
constexpr auto	FilterAdapterFromRange (R &range, Pred predicate) noexcept(noexcept(FilterAdapter< std::ranges::iterator_t< R >, Pred >(std::ranges::begin(range), std::ranges::end(range), std::move(predicate)))) -> FilterAdapter< std::ranges::iterator_t< R >, Pred >
	Helper function to create a FilterAdapter from a non-const range.

template<std::ranges::range R, typename Pred > requires FilterAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>())), Pred>
constexpr auto	FilterAdapterFromRange (const R &range, Pred predicate) noexcept(noexcept(FilterAdapter< decltype(std::ranges::cbegin(range)), Pred >(std::ranges::cbegin(range), std::ranges::cend(range), std::move(predicate)))) -> FilterAdapter< decltype(std::ranges::cbegin(range)), Pred >
	Helper function to create a FilterAdapter from a const range.

template<std::ranges::range R, typename Func > requires MapAdapterRequirements<std::ranges::iterator_t<R>, Func>
constexpr auto	MapAdapterFromRange (R &range, Func transform) noexcept(noexcept(MapAdapter< std::ranges::iterator_t< R >, Func >(std::ranges::begin(range), std::ranges::end(range), std::move(transform)))) -> MapAdapter< std::ranges::iterator_t< R >, Func >
	Helper function to create a MapAdapter from a range.

template<std::ranges::range R, typename Func > requires MapAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>())), Func>
constexpr auto	MapAdapterFromRange (const R &range, Func transform) noexcept(noexcept(MapAdapter< decltype(std::ranges::cbegin(range)), Func >(std::ranges::cbegin(range), std::ranges::cend(range), std::move(transform)))) -> MapAdapter< decltype(std::ranges::cbegin(range)), Func >
	Helper function to create a MapAdapter from a const range.

template<std::ranges::range R> requires TakeAdapterRequirements<std::ranges::iterator_t<R>>
constexpr auto	TakeAdapterFromRange (R &range, size_t count) noexcept(noexcept(TakeAdapter< std::ranges::iterator_t< R > >(std::ranges::begin(range), std::ranges::end(range), count))) -> TakeAdapter< std::ranges::iterator_t< R > >
	Helper function to create a TakeAdapter from a non-const range.

template<std::ranges::range R> requires TakeAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>()))>
constexpr auto	TakeAdapterFromRange (const R &range, size_t count) noexcept(noexcept(TakeAdapter< decltype(std::ranges::cbegin(range))>(std::ranges::cbegin(range), std::ranges::cend(range), count))) -> TakeAdapter< decltype(std::ranges::cbegin(range))>
	Helper function to create a TakeAdapter from a const range.

template<std::ranges::range R> requires SkipAdapterRequirements<std::ranges::iterator_t<R>>
constexpr auto	SkipAdapterFromRange (R &range, size_t count) noexcept(noexcept(SkipAdapter< std::ranges::iterator_t< R > >(std::ranges::begin(range), std::ranges::end(range), count))) -> SkipAdapter< std::ranges::iterator_t< R > >
	Helper function to create a SkipAdapter from a non-const range.

template<std::ranges::range R> requires SkipAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>()))>
constexpr auto	SkipAdapterFromRange (const R &range, size_t count) noexcept(noexcept(SkipAdapter< decltype(std::ranges::cbegin(range))>(std::ranges::cbegin(range), std::ranges::cend(range), count))) -> SkipAdapter< decltype(std::ranges::cbegin(range))>
	Helper function to create a SkipAdapter from a const range.

template<std::ranges::range R, typename Pred > requires TakeWhileAdapterRequirements<std::ranges::iterator_t<R>, Pred>
constexpr auto	TakeWhileAdapterFromRange (R &range, Pred predicate) noexcept(noexcept(TakeWhileAdapter< std::ranges::iterator_t< R >, Pred >(std::ranges::begin(range), std::ranges::end(range), std::move(predicate)))) -> TakeWhileAdapter< std::ranges::iterator_t< R >, Pred >
	Helper function to create a TakeWhileAdapter from a non-const range.

template<std::ranges::range R, typename Pred > requires TakeWhileAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>())), Pred>
constexpr auto	TakeWhileAdapterFromRange (const R &range, Pred predicate) noexcept(noexcept(TakeWhileAdapter< decltype(std::ranges::cbegin(range)), Pred >(std::ranges::cbegin(range), std::ranges::cend(range), std::move(predicate)))) -> TakeWhileAdapter< decltype(std::ranges::cbegin(range)), Pred >
	Helper function to create a TakeWhileAdapter from a const range.

template<std::ranges::range R, typename Pred > requires SkipWhileAdapterRequirements<std::ranges::iterator_t<R>, Pred>
constexpr auto	SkipWhileAdapterFromRange (R &range, Pred predicate) noexcept(noexcept(SkipWhileAdapter< std::ranges::iterator_t< R >, Pred >(std::ranges::begin(range), std::ranges::end(range), std::move(predicate)))) -> SkipWhileAdapter< std::ranges::iterator_t< R >, Pred >
	Helper function to create a SkipWhileAdapter from a non-const range.

template<std::ranges::range R, typename Pred > requires SkipWhileAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>())), Pred>
constexpr auto	SkipWhileAdapterFromRange (const R &range, Pred predicate) noexcept(noexcept(SkipWhileAdapter< decltype(std::ranges::cbegin(range)), Pred >(std::ranges::cbegin(range), std::ranges::cend(range), std::move(predicate)))) -> SkipWhileAdapter< decltype(std::ranges::cbegin(range)), Pred >
	Helper function to create a SkipWhileAdapter from a const range.

template<std::ranges::range R> requires EnumerateAdapterRequirements<std::ranges::iterator_t<R>>
constexpr auto	EnumerateAdapterFromRange (R &range) noexcept(noexcept(EnumerateAdapter< std::ranges::iterator_t< R > >(std::ranges::begin(range), std::ranges::end(range)))) -> EnumerateAdapter< std::ranges::iterator_t< R > >
	Helper function to create an EnumerateAdapter from a non-const range.

template<std::ranges::range R> requires EnumerateAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>()))>
constexpr auto	EnumerateAdapterFromRange (const R &range) noexcept(noexcept(EnumerateAdapter< decltype(std::ranges::cbegin(range))>(std::ranges::cbegin(range), std::ranges::cend(range)))) -> EnumerateAdapter< decltype(std::ranges::cbegin(range))>
	Helper function to create an EnumerateAdapter from a const range.

template<std::ranges::range R, typename Func > requires InspectAdapterRequirements<std::ranges::iterator_t<R>, Func>
constexpr auto	InspectAdapterFromRange (R &range, Func inspector) noexcept(noexcept(InspectAdapter< std::ranges::iterator_t< R >, Func >(std::ranges::begin(range), std::ranges::end(range), std::move(inspector)))) -> InspectAdapter< std::ranges::iterator_t< R >, Func >
	Helper function to create an InspectAdapter from a non-const range.

template<std::ranges::range R, typename Func > requires InspectAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>())), Func>
constexpr auto	InspectAdapterFromRange (const R &range, Func inspector) noexcept(noexcept(InspectAdapter< decltype(std::ranges::cbegin(range)), Func >(std::ranges::cbegin(range), std::ranges::cend(range), std::move(inspector)))) -> InspectAdapter< decltype(std::ranges::cbegin(range)), Func >
	Helper function to create an InspectAdapter from a const range.

template<std::ranges::range R> requires StepByAdapterRequirements<std::ranges::iterator_t<R>>
constexpr auto	StepByAdapterFromRange (R &range, size_t step) noexcept(noexcept(StepByAdapter< std::ranges::iterator_t< R > >(std::ranges::begin(range), std::ranges::end(range), step))) -> StepByAdapter< std::ranges::iterator_t< R > >
	Helper function to create a StepByAdapter from a non-const range.

template<std::ranges::range R> requires StepByAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>()))>
constexpr auto	StepByAdapterFromRange (const R &range, size_t step) noexcept(noexcept(StepByAdapter< decltype(std::ranges::cbegin(range))>(std::ranges::cbegin(range), std::ranges::cend(range), step))) -> StepByAdapter< decltype(std::ranges::cbegin(range))>
	Helper function to create a StepByAdapter from a const range.

template<std::ranges::range R1, std::ranges::range R2> requires ChainAdapterRequirements<std::ranges::iterator_t<R1>, std::ranges::iterator_t<R2>>
constexpr auto	ChainAdapterFromRange (R1 &range1, R2 &range2) noexcept(noexcept(ChainAdapter< std::ranges::iterator_t< R1 >, std::ranges::iterator_t< R2 > >(std::ranges::begin(range1), std::ranges::end(range1), std::ranges::begin(range2), std::ranges::end(range2)))) -> ChainAdapter< std::ranges::iterator_t< R1 >, std::ranges::iterator_t< R2 > >
	Helper function to create a ChainAdapter from two non-const ranges.

template<std::ranges::range R1, std::ranges::range R2> requires ChainAdapterRequirements<std::ranges::iterator_t<R1>, decltype(std::ranges::cbegin(std::declval<const R2&>()))>
constexpr auto	ChainAdapterFromRange (R1 &range1, const R2 &range2) noexcept(noexcept(ChainAdapter< std::ranges::iterator_t< R1 >, decltype(std::ranges::cbegin(range2))>(std::ranges::begin(range1), std::ranges::end(range1), std::ranges::cbegin(range2), std::ranges::cend(range2)))) -> ChainAdapter< std::ranges::iterator_t< R1 >, decltype(std::ranges::cbegin(range2))>
	Helper function to create a ChainAdapter from non-const and const ranges.

template<std::ranges::range R1, std::ranges::range R2> requires ChainAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R1&>())), std::ranges::iterator_t<R2>>
constexpr auto	ChainAdapterFromRange (const R1 &range1, R2 &range2) noexcept(noexcept(ChainAdapter< decltype(std::ranges::cbegin(range1)), std::ranges::iterator_t< R2 > >(std::ranges::cbegin(range1), std::ranges::cend(range1), std::ranges::begin(range2), std::ranges::end(range2)))) -> ChainAdapter< decltype(std::ranges::cbegin(range1)), std::ranges::iterator_t< R2 > >
	Helper function to create a ChainAdapter from const and non-const ranges.

template<std::ranges::range R1, std::ranges::range R2> requires ChainAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R1&>())), decltype(std::ranges::cbegin(std::declval<const R2&>()))>
constexpr auto	ChainAdapterFromRange (const R1 &range1, const R2 &range2) noexcept(noexcept(ChainAdapter< decltype(std::ranges::cbegin(range1)), decltype(std::ranges::cbegin(range2))>(std::ranges::cbegin(range1), std::ranges::cend(range1), std::ranges::cbegin(range2), std::ranges::cend(range2)))) -> ChainAdapter< decltype(std::ranges::cbegin(range1)), decltype(std::ranges::cbegin(range2))>
	Helper function to create a ChainAdapter from two const ranges.

template<std::ranges::range R> requires ReverseAdapterRequirements<std::ranges::iterator_t<R>>
constexpr auto	ReverseAdapterFromRange (R &range) noexcept(noexcept(ReverseAdapter< std::ranges::iterator_t< R > >(std::ranges::begin(range), std::ranges::end(range)))) -> ReverseAdapter< std::ranges::iterator_t< R > >
	Helper function to create a ReverseAdapter from a range.

template<std::ranges::range R> requires ReverseAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>()))>
constexpr auto	ReverseAdapterFromRange (const R &range) noexcept(noexcept(ReverseAdapter< decltype(std::ranges::cbegin(range))>(std::ranges::cbegin(range), std::ranges::cend(range)))) -> ReverseAdapter< decltype(std::ranges::cbegin(range))>
	Helper function to create a ReverseAdapter from a const range.

template<std::ranges::range R> requires JoinAdapterRequirements<std::ranges::iterator_t<R>>
constexpr auto	JoinAdapterFromRange (R &range) noexcept(noexcept(JoinAdapter< std::ranges::iterator_t< R > >(std::ranges::begin(range), std::ranges::end(range)))) -> JoinAdapter< std::ranges::iterator_t< R > >
	Helper function to create a JoinAdapter from a range.

template<std::ranges::range R> requires JoinAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>()))>
constexpr auto	JoinAdapterFromRange (const R &range) noexcept(noexcept(JoinAdapter< decltype(std::ranges::cbegin(range))>(std::ranges::cbegin(range), std::ranges::cend(range)))) -> JoinAdapter< decltype(std::ranges::cbegin(range))>
	Helper function to create a JoinAdapter from a const range.

template<std::ranges::range R> requires SlideAdapterRequirements<std::ranges::iterator_t<R>>
constexpr auto	SlideAdapterFromRange (R &range, size_t window_size) noexcept(noexcept(SlideAdapter< std::ranges::iterator_t< R > >(std::ranges::begin(range), std::ranges::end(range), window_size))) -> SlideAdapter< std::ranges::iterator_t< R > >
	Helper function to create a SlideAdapter from a range.

template<std::ranges::range R> requires SlideAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>()))>
constexpr auto	SlideAdapterFromRange (const R &range, size_t window_size) noexcept(noexcept(SlideAdapter< decltype(std::ranges::cbegin(range))>(std::ranges::cbegin(range), std::ranges::cend(range), window_size))) -> SlideAdapter< decltype(std::ranges::cbegin(range))>
	Helper function to create a SlideAdapter from a const range.

template<std::ranges::range R> requires StrideAdapterRequirements<std::ranges::iterator_t<R>>
constexpr auto	StrideAdapterFromRange (R &range, size_t stride) noexcept(noexcept(StrideAdapter< std::ranges::iterator_t< R > >(std::ranges::begin(range), std::ranges::end(range), stride))) -> StrideAdapter< std::ranges::iterator_t< R > >
	Helper function to create a StrideAdapter from a range.

template<std::ranges::range R> requires StrideAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>()))>
constexpr auto	StrideAdapterFromRange (const R &range, size_t stride) noexcept(noexcept(StrideAdapter< decltype(std::ranges::cbegin(range))>(std::ranges::cbegin(range), std::ranges::cend(range), stride))) -> StrideAdapter< decltype(std::ranges::cbegin(range))>
	Helper function to create a StrideAdapter from a const range.

template<std::ranges::range R1, std::ranges::range R2> requires ZipAdapterRequirements<std::ranges::iterator_t<R1>, std::ranges::iterator_t<R2>>
constexpr auto	ZipAdapterFromRange (R1 &range1, R2 &range2) noexcept(noexcept(ZipAdapter< std::ranges::iterator_t< R1 >, std::ranges::iterator_t< R2 > >(std::ranges::begin(range1), std::ranges::end(range1), std::ranges::begin(range2), std::ranges::end(range2)))) -> ZipAdapter< std::ranges::iterator_t< R1 >, std::ranges::iterator_t< R2 > >
	Helper function to create a ZipAdapter from two ranges.

template<std::ranges::range R1, std::ranges::range R2> requires ZipAdapterRequirements<std::ranges::iterator_t<R1>, decltype(std::ranges::cbegin(std::declval<const R2&>()))>
constexpr auto	ZipAdapterFromRange (R1 &range1, const R2 &range2) noexcept(noexcept(ZipAdapter< std::ranges::iterator_t< R1 >, decltype(std::ranges::cbegin(range2))>(std::ranges::begin(range1), std::ranges::end(range1), std::ranges::cbegin(range2), std::ranges::cend(range2)))) -> ZipAdapter< std::ranges::iterator_t< R1 >, decltype(std::ranges::cbegin(range2))>
	Helper function to create a ZipAdapter from a range and a const range.

template<std::ranges::range R1, std::ranges::range R2> requires ZipAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R1&>())), decltype(std::ranges::cbegin(std::declval<const R2&>()))>
constexpr auto	ZipAdapterFromRange (const R1 &range1, const R2 &range2) noexcept(noexcept(ZipAdapter< decltype(std::ranges::cbegin(range1)), decltype(std::ranges::cbegin(range2))>(std::ranges::cbegin(range1), std::ranges::cend(range1), std::ranges::cbegin(range2), std::ranges::cend(range2)))) -> ZipAdapter< decltype(std::ranges::cbegin(range1)), decltype(std::ranges::cbegin(range2))>
	Helper function to create a ZipAdapter from two const ranges.

template<std::ranges::range R> requires ConcatAdapterRequirements<std::ranges::iterator_t<R>>
constexpr auto	ConcatAdapterFromRange (R &range1, R &range2) noexcept(noexcept(ConcatAdapter< std::ranges::iterator_t< R > >(std::ranges::begin(range1), std::ranges::end(range1), std::ranges::begin(range2), std::ranges::end(range2)))) -> ConcatAdapter< std::ranges::iterator_t< R > >

template<std::ranges::range R> requires ConcatAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>()))>
constexpr auto	ConcatAdapterFromRange (const R &range1, const R &range2) noexcept(noexcept(ConcatAdapter< decltype(std::ranges::cbegin(range1))>(std::ranges::cbegin(range1), std::ranges::cend(range1), std::ranges::cbegin(range2), std::ranges::cend(range2)))) -> ConcatAdapter< decltype(std::ranges::cbegin(range1))>

template<std::ranges::range R> requires ConcatAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>()))>
constexpr auto	ConcatAdapterFromRange (R &range1, const R &range2) noexcept(noexcept(ConcatAdapter< decltype(std::ranges::cbegin(std::declval< const R & >()))>(std::ranges::cbegin(range1), std::ranges::cend(range1), std::ranges::cbegin(range2), std::ranges::cend(range2)))) -> ConcatAdapter< decltype(std::ranges::cbegin(std::declval< const R & >()))>
	Helper function to create a ConcatAdapter from a non-const and const range of the same type.

template<std::ranges::range R> requires ConcatAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>()))>
constexpr auto	ConcatAdapterFromRange (const R &range1, R &range2) noexcept(noexcept(ConcatAdapter< decltype(std::ranges::cbegin(std::declval< const R & >()))>(std::ranges::cbegin(range1), std::ranges::cend(range1), std::ranges::cbegin(range2), std::ranges::cend(range2)))) -> ConcatAdapter< decltype(std::ranges::cbegin(std::declval< const R & >()))>
	Helper function to create a ConcatAdapter from a const and non-const range of the same type.

Enumeration Type Documentation

◆ DynamicLibraryError

enum class helios::utils::DynamicLibraryError : uint8_t

strong

Error codes for dynamic library operations.

Enumerator
FileNotFound	Library file not found.
LoadFailed	Failed to load library.
SymbolNotFound	Symbol not found in library.
InvalidHandle	Invalid library handle.
AlreadyLoaded	Library is already loaded.
NotLoaded	Library is not loaded.
PlatformError	Platform-specific error.

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

Definition at line 19 of file dynamic_library.hpp.

                               : uint8_t {
  FileNotFound,    ///< Library file not found
  LoadFailed,      ///< Failed to load library
  SymbolNotFound,  ///< Symbol not found in library
  InvalidHandle,   ///< Invalid library handle
  AlreadyLoaded,   ///< Library is already loaded
  NotLoaded,       ///< Library is not loaded
  PlatformError,   ///< Platform-specific error
};

◆ FileError

enum class helios::utils::FileError : uint8_t

strong

Enumerator
kCouldNotOpen
kReadError

Definition at line 16 of file filesystem.hpp.

16: uint8_t { kCouldNotOpen, kReadError };

helios::utils::FileError::kReadError

@ kReadError

helios::utils::FileError::kCouldNotOpen

@ kCouldNotOpen

Function Documentation

◆ ChainAdapterFromRange() [1/4]

template<std::ranges::range R1, std::ranges::range R2>
requires ChainAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R1&>())), decltype(std::ranges::cbegin(std::declval<const R2&>()))>

constexpr auto helios::utils::ChainAdapterFromRange	(	const R1 &	range1,
		const R2 &	range2
	)		-> ChainAdapter<decltype(std::ranges::cbegin(range1)), decltype(std::ranges::cbegin(range2))>

constexprnoexcept

Helper function to create a ChainAdapter from two const ranges.

Template Parameters

R1	First range type
R2	Second range type

Parameters

range1	First range
range2	Second range

Returns: ChainAdapter for the two ranges

Definition at line 3638 of file functional_adapters.hpp.

                                                                                          {
  return {std::ranges::cbegin(range1), std::ranges::cend(range1), std::ranges::cbegin(range2),
          std::ranges::cend(range2)};
}

◆ ChainAdapterFromRange() [2/4]

template<std::ranges::range R1, std::ranges::range R2>
requires ChainAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R1&>())), std::ranges::iterator_t<R2>>

constexpr auto helios::utils::ChainAdapterFromRange	(	const R1 &	range1,
		R2 &	range2
	)		-> ChainAdapter<decltype(std::ranges::cbegin(range1)), std::ranges::iterator_t<R2>>

constexprnoexcept

Helper function to create a ChainAdapter from const and non-const ranges.

Template Parameters

R1	First range type
R2	Second range type

Parameters

range1	First range
range2	Second range

Returns: ChainAdapter for the two ranges

Definition at line 3620 of file functional_adapters.hpp.

                                                                                {
  return {std::ranges::cbegin(range1), std::ranges::cend(range1), std::ranges::begin(range2), std::ranges::end(range2)};
}

◆ ChainAdapterFromRange() [3/4]

template<std::ranges::range R1, std::ranges::range R2>
requires ChainAdapterRequirements<std::ranges::iterator_t<R1>, decltype(std::ranges::cbegin(std::declval<const R2&>()))>

constexpr auto helios::utils::ChainAdapterFromRange	(	R1 &	range1,
		const R2 &	range2
	)		-> ChainAdapter<std::ranges::iterator_t<R1>, decltype(std::ranges::cbegin(range2))>

constexprnoexcept

Helper function to create a ChainAdapter from non-const and const ranges.

Template Parameters

R1	First range type
R2	Second range type

Parameters

range1	First range
range2	Second range

Returns: ChainAdapter for the two ranges

Definition at line 3602 of file functional_adapters.hpp.

                                                                                {
  return {std::ranges::begin(range1), std::ranges::end(range1), std::ranges::cbegin(range2), std::ranges::cend(range2)};
}

◆ ChainAdapterFromRange() [4/4]

template<std::ranges::range R1, std::ranges::range R2>
requires ChainAdapterRequirements<std::ranges::iterator_t<R1>, std::ranges::iterator_t<R2>>

constexpr auto helios::utils::ChainAdapterFromRange	(	R1 &	range1,
		R2 &	range2
	)		-> ChainAdapter<std::ranges::iterator_t<R1>, std::ranges::iterator_t<R2>>

constexprnoexcept

Helper function to create a ChainAdapter from two non-const ranges.

Template Parameters

R1	First range type
R2	Second range type

Parameters

range1	First range
range2	Second range

Returns: ChainAdapter for the two ranges

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

Definition at line 3584 of file functional_adapters.hpp.

                                                                      {
  return {std::ranges::begin(range1), std::ranges::end(range1), std::ranges::begin(range2), std::ranges::end(range2)};
}

◆ ConcatAdapterFromRange() [1/4]

template<std::ranges::range R>
requires ConcatAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>()))>

constexpr auto helios::utils::ConcatAdapterFromRange	(	const R &	range1,
		const R &	range2
	)		-> ConcatAdapter<decltype(std::ranges::cbegin(range1))>

constexprnoexcept

Definition at line 3864 of file functional_adapters.hpp.

                                                        {
  return {std::ranges::cbegin(range1), std::ranges::cend(range1), std::ranges::cbegin(range2),
          std::ranges::cend(range2)};
}

◆ ConcatAdapterFromRange() [2/4]

template<std::ranges::range R>
requires ConcatAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>()))>

constexpr auto helios::utils::ConcatAdapterFromRange	(	const R &	range1,
		R &	range2
	)		-> ConcatAdapter<decltype(std::ranges::cbegin(std::declval<const R&>()))>

constexprnoexcept

Helper function to create a ConcatAdapter from a const and non-const range of the same type.

Template Parameters

R	Range type (must be the same for both)

Parameters

range1	First range (const)
range2	Second range (non-const)

Returns: ConcatAdapter for the two ranges using const iterators

Definition at line 3900 of file functional_adapters.hpp.

                                                                        {
  return {std::ranges::cbegin(range1), std::ranges::cend(range1), std::ranges::cbegin(range2),
          std::ranges::cend(range2)};
}

◆ ConcatAdapterFromRange() [3/4]

template<std::ranges::range R>
requires ConcatAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>()))>

constexpr auto helios::utils::ConcatAdapterFromRange	(	R &	range1,
		const R &	range2
	)		-> ConcatAdapter<decltype(std::ranges::cbegin(std::declval<const R&>()))>

constexprnoexcept

Helper function to create a ConcatAdapter from a non-const and const range of the same type.

Template Parameters

R	Range type (must be the same for both)

Parameters

range1	First range (non-const)
range2	Second range (const)

Returns: ConcatAdapter for the two ranges using const iterators

Definition at line 3881 of file functional_adapters.hpp.

                                                                        {
  return {std::ranges::cbegin(range1), std::ranges::cend(range1), std::ranges::cbegin(range2),
          std::ranges::cend(range2)};
}

◆ ConcatAdapterFromRange() [4/4]

template<std::ranges::range R>
requires ConcatAdapterRequirements<std::ranges::iterator_t<R>>

constexpr auto helios::utils::ConcatAdapterFromRange	(	R &	range1,
		R &	range2
	)		-> ConcatAdapter<std::ranges::iterator_t<R>>

constexprnoexcept

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

Definition at line 3838 of file functional_adapters.hpp.

                                             {
  return {std::ranges::begin(range1), std::ranges::end(range1), std::ranges::begin(range2), std::ranges::end(range2)};
}

◆ DynamicLibraryErrorToString()

constexpr std::string_view helios::utils::DynamicLibraryErrorToString ( DynamicLibraryError error )

constexprnoexcept

Gets a human-readable description for a DynamicLibraryError.

Parameters

error The error code

Returns: String description of the error

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

Definition at line 34 of file dynamic_library.hpp.

                                                                                                       {
  switch (error) {
    case DynamicLibraryError::FileNotFound:
      return "Library file not found";
    case DynamicLibraryError::LoadFailed:
      return "Failed to load library";
    case DynamicLibraryError::SymbolNotFound:
      return "Symbol not found in library";
    case DynamicLibraryError::InvalidHandle:
      return "Invalid library handle";
    case DynamicLibraryError::AlreadyLoaded:
      return "Library is already loaded";
    case DynamicLibraryError::NotLoaded:
      return "Library is not loaded";
    case DynamicLibraryError::PlatformError:
      return "Platform-specific error";
    default:
      return "Unknown error";
  }
}

◆ EnumerateAdapterFromRange() [1/2]

template<std::ranges::range R>
requires EnumerateAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>()))>

constexpr auto helios::utils::EnumerateAdapterFromRange ( const R & range ) -> EnumerateAdapter<decltype(std::ranges::cbegin(range))>

constexprnoexcept

Helper function to create an EnumerateAdapter from a const range.

Template Parameters

R	Range type

Parameters

range Range to enumerate

Returns: EnumerateAdapter for the range

Definition at line 3504 of file functional_adapters.hpp.

                                                          {
  return {std::ranges::cbegin(range), std::ranges::cend(range)};
}

◆ EnumerateAdapterFromRange() [2/2]

template<std::ranges::range R>
requires EnumerateAdapterRequirements<std::ranges::iterator_t<R>>

constexpr auto helios::utils::EnumerateAdapterFromRange ( R & range ) -> EnumerateAdapter<std::ranges::iterator_t<R>>

constexprnoexcept

Helper function to create an EnumerateAdapter from a non-const range.

Template Parameters

R	Range type

Parameters

range Range to enumerate

Returns: EnumerateAdapter for the range

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

Definition at line 3490 of file functional_adapters.hpp.

                                                {
  return {std::ranges::begin(range), std::ranges::end(range)};
}

◆ FileErrorToString()

constexpr std::string_view helios::utils::FileErrorToString ( FileError error )

constexprnoexcept

Converts FileError to a human-readable string.

Parameters

error The FileError to convert

Returns: A string view representing the error

Definition at line 23 of file filesystem.hpp.

                                                                                   {
  switch (error) {
    case FileError::kCouldNotOpen:
      return "Could not open file";
    case FileError::kReadError:
      return "Could not read file";
    default:
      return "Unknown file error";
  }
}

◆ FilterAdapterFromRange() [1/2]

template<std::ranges::range R, typename Pred >
requires FilterAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>())), Pred>

constexpr auto helios::utils::FilterAdapterFromRange	(	const R &	range,
		Pred	predicate
	)		-> FilterAdapter<decltype(std::ranges::cbegin(range)), Pred>

constexprnoexcept

Helper function to create a FilterAdapter from a const range.

Template Parameters

R	Range type
Pred	Predicate type

Parameters

range	Range to filter
predicate	Function to filter elements

Returns: FilterAdapter for the range

Definition at line 3313 of file functional_adapters.hpp.

                                                             {
  return {std::ranges::cbegin(range), std::ranges::cend(range), std::move(predicate)};
}

◆ FilterAdapterFromRange() [2/2]

template<std::ranges::range R, typename Pred >
requires FilterAdapterRequirements<std::ranges::iterator_t<R>, Pred>

constexpr auto helios::utils::FilterAdapterFromRange	(	R &	range,
		Pred	predicate
	)		-> FilterAdapter<std::ranges::iterator_t<R>, Pred>

constexprnoexcept

Helper function to create a FilterAdapter from a non-const range.

Template Parameters

R	Range type
Pred	Predicate type

Parameters

range	Range to filter
predicate	Function to filter elements

Returns: FilterAdapter for the range

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

Definition at line 3296 of file functional_adapters.hpp.

                                                   {
  return {std::ranges::begin(range), std::ranges::end(range), std::move(predicate)};
}

◆ FromPath()

auto helios::utils::FromPath ( const std::filesystem::path & path ) -> std::expected<DynamicLibrary, DynamicLibraryError>

inline

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

Definition at line 228 of file dynamic_library.hpp.

                                                                                                        {
  DynamicLibrary lib;
  if (const auto result = lib.Load(path); !result) {
    return std::unexpected(result.error());
  }
  return lib;
}

◆ GetFileExtension()

static constexpr std::string_view helios::utils::GetFileExtension ( std::string_view path )

staticconstexpr

Extracts the file extension from a given path.

Parameters

path	The full file path

Returns: The file extension, including the dot (e.g., ".txt"), or an empty string if none exists

Definition at line 118 of file filesystem.hpp.

                                                                                    {
  const size_t last_dot = path.find_last_of('.');
  return (last_dot != std::string_view::npos) ? path.substr(last_dot) : "";
}

◆ GetFileName()

constexpr std::string_view helios::utils::GetFileName ( std::string_view path )

constexpr

Extracts the file name from a given path.

Parameters

path	The full file path

Returns: The file name

Definition at line 108 of file filesystem.hpp.

                                                                        {
  const size_t last_slash = path.find_last_of("/\\");
  return (last_slash != std::string_view::npos) ? path.substr(last_slash + 1) : path;
}

◆ InspectAdapterFromRange() [1/2]

template<std::ranges::range R, typename Func >
requires InspectAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>())), Func>

constexpr auto helios::utils::InspectAdapterFromRange	(	const R &	range,
		Func	inspector
	)		-> InspectAdapter<decltype(std::ranges::cbegin(range)), Func>

constexprnoexcept

Helper function to create an InspectAdapter from a const range.

Template Parameters

R	Range type
Func	Inspector function type

Parameters

range	Range to inspect
inspector	Function to call for each element

Returns: InspectAdapter for the range

Definition at line 3537 of file functional_adapters.hpp.

                                                              {
  return {std::ranges::cbegin(range), std::ranges::cend(range), std::move(inspector)};
}

◆ InspectAdapterFromRange() [2/2]

template<std::ranges::range R, typename Func >
requires InspectAdapterRequirements<std::ranges::iterator_t<R>, Func>

constexpr auto helios::utils::InspectAdapterFromRange	(	R &	range,
		Func	inspector
	)		-> InspectAdapter<std::ranges::iterator_t<R>, Func>

constexprnoexcept

Helper function to create an InspectAdapter from a non-const range.

Template Parameters

R	Range type
Func	Inspector function type

Parameters

range	Range to inspect
inspector	Function to call on each element

Returns: InspectAdapter for the range

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

Definition at line 3520 of file functional_adapters.hpp.

                                                    {
  return {std::ranges::begin(range), std::ranges::end(range), std::move(inspector)};
}

◆ JoinAdapterFromRange() [1/2]

template<std::ranges::range R>
requires JoinAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>()))>

constexpr auto helios::utils::JoinAdapterFromRange ( const R & range ) -> JoinAdapter<decltype(std::ranges::cbegin(range))>

constexprnoexcept

Helper function to create a JoinAdapter from a const range.

Template Parameters

R	Range type

Parameters

range Range to join

Returns: JoinAdapter for the range

Definition at line 3697 of file functional_adapters.hpp.

                                                     {
  return {std::ranges::cbegin(range), std::ranges::cend(range)};
}

◆ JoinAdapterFromRange() [2/2]

template<std::ranges::range R>
requires JoinAdapterRequirements<std::ranges::iterator_t<R>>

constexpr auto helios::utils::JoinAdapterFromRange ( R & range ) -> JoinAdapter<std::ranges::iterator_t<R>>

constexprnoexcept

Helper function to create a JoinAdapter from a range.

Template Parameters

R	Range type

Parameters

range Range to join

Returns: JoinAdapter for the range

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

Definition at line 3683 of file functional_adapters.hpp.

                                           {
  return {std::ranges::begin(range), std::ranges::end(range)};
}

◆ MapAdapterFromRange() [1/2]

template<std::ranges::range R, typename Func >
requires MapAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>())), Func>

constexpr auto helios::utils::MapAdapterFromRange	(	const R &	range,
		Func	transform
	)		-> MapAdapter<decltype(std::ranges::cbegin(range)), Func>

constexprnoexcept

Helper function to create a MapAdapter from a const range.

Template Parameters

R	Range type
Func	Transformation function type

Parameters

range	Range to map
transform	Function to apply to each element

Returns: MapAdapter for the range

Definition at line 3347 of file functional_adapters.hpp.

                                                          {
  return {std::ranges::cbegin(range), std::ranges::cend(range), std::move(transform)};
}

◆ MapAdapterFromRange() [2/2]

template<std::ranges::range R, typename Func >
requires MapAdapterRequirements<std::ranges::iterator_t<R>, Func>

constexpr auto helios::utils::MapAdapterFromRange	(	R &	range,
		Func	transform
	)		-> MapAdapter<std::ranges::iterator_t<R>, Func>

constexprnoexcept

Helper function to create a MapAdapter from a range.

Template Parameters

R	Range type
Func	Transformation function type

Parameters

range	Range to map
transform	Function to apply to each element

Returns: MapAdapter for the range

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

Definition at line 3330 of file functional_adapters.hpp.

                                                {
  return {std::ranges::begin(range), std::ranges::end(range), std::move(transform)};
}

◆ ReadFileToString() [1/2]

auto helios::utils::ReadFileToString ( const std::filesystem::path & filepath ) -> std::expected<std::string, FileError>

inline

Reads the entire contents of a file into a string.

Parameters

filepath The path to the file

Returns: An expected containing the file contents or a FileError

Definition at line 73 of file filesystem.hpp.

                                         {
  if (filepath.empty()) {
    return std::unexpected(FileError::kCouldNotOpen);
  }
 
  std::ifstream in(filepath, std::ios::in | std::ios::binary);
  if (!in) {
    return std::unexpected(FileError::kCouldNotOpen);
  }
 
  std::string result;
  in.seekg(0, std::ios::end);
  const auto pos = in.tellg();
  if (pos == std::ifstream::pos_type(-1)) {
    return std::unexpected(FileError::kReadError);
  }
 
  const auto size = static_cast<size_t>(pos);
  result.resize(size);
  in.seekg(0, std::ios::beg);
  in.read(result.data(), static_cast<std::streamsize>(result.size()));
  if (!in) {
    return std::unexpected(FileError::kReadError);
  }
  in.close();
 
  return result;
}

◆ ReadFileToString() [2/2]

auto helios::utils::ReadFileToString ( std::string_view filepath ) -> std::expected<std::string, FileError>

inline

Reads the entire contents of a file into a string.

Parameters

filepath The path to the file

Returns: An expected containing the file contents or a FileError

Definition at line 39 of file filesystem.hpp.

                                                                                                         {
  if (filepath.empty()) {
    return std::unexpected(FileError::kCouldNotOpen);
  }
 
  std::ifstream in(filepath.data(), std::ios::in | std::ios::binary);
  if (!in) {
    return std::unexpected(FileError::kCouldNotOpen);
  }
 
  std::string result;
  in.seekg(0, std::ios::end);
  const auto pos = in.tellg();
  if (pos == std::ifstream::pos_type(-1)) {
    return std::unexpected(FileError::kReadError);
  }
 
  const auto size = static_cast<size_t>(pos);
  result.resize(size);
  in.seekg(0, std::ios::beg);
  in.read(result.data(), static_cast<std::streamsize>(result.size()));
  if (!in) {
    return std::unexpected(FileError::kReadError);
  }
  in.close();
 
  return result;
}

◆ ReverseAdapterFromRange() [1/2]

template<std::ranges::range R>
requires ReverseAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>()))>

constexpr auto helios::utils::ReverseAdapterFromRange ( const R & range ) -> ReverseAdapter<decltype(std::ranges::cbegin(range))>

constexprnoexcept

Helper function to create a ReverseAdapter from a const range.

Template Parameters

R	Range type

Parameters

range Range to reverse

Returns: ReverseAdapter for the range

Definition at line 3669 of file functional_adapters.hpp.

                                                        {
  return {std::ranges::cbegin(range), std::ranges::cend(range)};
}

◆ ReverseAdapterFromRange() [2/2]

template<std::ranges::range R>
requires ReverseAdapterRequirements<std::ranges::iterator_t<R>>

constexpr auto helios::utils::ReverseAdapterFromRange ( R & range ) -> ReverseAdapter<std::ranges::iterator_t<R>>

constexprnoexcept

Helper function to create a ReverseAdapter from a range.

Template Parameters

R	Range type

Parameters

range Range to reverse

Returns: ReverseAdapter for the range

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

Definition at line 3655 of file functional_adapters.hpp.

                                              {
  return {std::ranges::begin(range), std::ranges::end(range)};
}

◆ SkipAdapterFromRange() [1/2]

template<std::ranges::range R>
requires SkipAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>()))>

constexpr auto helios::utils::SkipAdapterFromRange	(	const R &	range,
		size_t	count
	)		-> SkipAdapter<decltype(std::ranges::cbegin(range))>

constexprnoexcept

Helper function to create a SkipAdapter from a const range.

Template Parameters

R	Range type

Parameters

range	Range to skip from
count	Number of elements to skip

Returns: SkipAdapter for the range

Definition at line 3408 of file functional_adapters.hpp.

                                                     {
  return {std::ranges::cbegin(range), std::ranges::cend(range), count};
}

◆ SkipAdapterFromRange() [2/2]

template<std::ranges::range R>
requires SkipAdapterRequirements<std::ranges::iterator_t<R>>

constexpr auto helios::utils::SkipAdapterFromRange	(	R &	range,
		size_t	count
	)		-> SkipAdapter<std::ranges::iterator_t<R>>

constexprnoexcept

Helper function to create a SkipAdapter from a non-const range.

Template Parameters

R	Range type

Parameters

range	Range to skip from
count	Number of elements to skip

Returns: SkipAdapter for the range

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

Definition at line 3393 of file functional_adapters.hpp.

                                           {
  return {std::ranges::begin(range), std::ranges::end(range), count};
}

◆ SkipWhileAdapterFromRange() [1/2]

template<std::ranges::range R, typename Pred >
requires SkipWhileAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>())), Pred>

constexpr auto helios::utils::SkipWhileAdapterFromRange	(	const R &	range,
		Pred	predicate
	)		-> SkipWhileAdapter<decltype(std::ranges::cbegin(range)), Pred>

constexprnoexcept

Helper function to create a SkipWhileAdapter from a const range.

Template Parameters

R	Range type
Pred	Predicate type

Parameters

range	Range to skip from
predicate	Predicate to test elements

Returns: SkipWhileAdapter for the range

Definition at line 3475 of file functional_adapters.hpp.

                                                                {
  return {std::ranges::cbegin(range), std::ranges::cend(range), std::move(predicate)};
}

◆ SkipWhileAdapterFromRange() [2/2]

template<std::ranges::range R, typename Pred >
requires SkipWhileAdapterRequirements<std::ranges::iterator_t<R>, Pred>

constexpr auto helios::utils::SkipWhileAdapterFromRange	(	R &	range,
		Pred	predicate
	)		-> SkipWhileAdapter<std::ranges::iterator_t<R>, Pred>

constexprnoexcept

Helper function to create a SkipWhileAdapter from a non-const range.

Template Parameters

R	Range type
Pred	Predicate type

Parameters

range	Range to skip from
predicate	Predicate to test elements

Returns: SkipWhileAdapter for the range

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

Definition at line 3458 of file functional_adapters.hpp.

                                                      {
  return {std::ranges::begin(range), std::ranges::end(range), std::move(predicate)};
}

◆ SlideAdapterFromRange() [1/2]

template<std::ranges::range R>
requires SlideAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>()))>

constexpr auto helios::utils::SlideAdapterFromRange	(	const R &	range,
		size_t	window_size
	)		-> SlideAdapter<decltype(std::ranges::cbegin(range))>

constexprnoexcept

Helper function to create a SlideAdapter from a const range.

Template Parameters

R	Range type

Parameters

range	Range to slide over
window_size	Size of the sliding window

Returns: SlideAdapter for the range

Definition at line 3727 of file functional_adapters.hpp.

                                                      {
  return {std::ranges::cbegin(range), std::ranges::cend(range), window_size};
}

◆ SlideAdapterFromRange() [2/2]

template<std::ranges::range R>
requires SlideAdapterRequirements<std::ranges::iterator_t<R>>

constexpr auto helios::utils::SlideAdapterFromRange	(	R &	range,
		size_t	window_size
	)		-> SlideAdapter<std::ranges::iterator_t<R>>

constexprnoexcept

Helper function to create a SlideAdapter from a range.

Template Parameters

R	Range type

Parameters

range	Range to slide over
window_size	Size of the sliding window

Returns: SlideAdapter for the range

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

Definition at line 3712 of file functional_adapters.hpp.

                                            {
  return {std::ranges::begin(range), std::ranges::end(range), window_size};
}

◆ StepByAdapterFromRange() [1/2]

template<std::ranges::range R>
requires StepByAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>()))>

constexpr auto helios::utils::StepByAdapterFromRange	(	const R &	range,
		size_t	step
	)		-> StepByAdapter<decltype(std::ranges::cbegin(range))>

constexprnoexcept

Helper function to create a StepByAdapter from a const range.

Template Parameters

R	Range type

Parameters

range	Range to step through
step	Number of elements to step by

Returns: StepByAdapter for the range

Definition at line 3568 of file functional_adapters.hpp.

                                                       {
  return {std::ranges::cbegin(range), std::ranges::cend(range), step};
}

◆ StepByAdapterFromRange() [2/2]

template<std::ranges::range R>
requires StepByAdapterRequirements<std::ranges::iterator_t<R>>

constexpr auto helios::utils::StepByAdapterFromRange	(	R &	range,
		size_t	step
	)		-> StepByAdapter<std::ranges::iterator_t<R>>

constexprnoexcept

Helper function to create a StepByAdapter from a non-const range.

Template Parameters

R	Range type

Parameters

range	Range to step through
step	Step size

Returns: StepByAdapter for the range

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

Definition at line 3553 of file functional_adapters.hpp.

                                             {
  return {std::ranges::begin(range), std::ranges::end(range), step};
}

◆ StrideAdapterFromRange() [1/2]

template<std::ranges::range R>
requires StrideAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>()))>

constexpr auto helios::utils::StrideAdapterFromRange	(	const R &	range,
		size_t	stride
	)		-> StrideAdapter<decltype(std::ranges::cbegin(range))>

constexprnoexcept

Helper function to create a StrideAdapter from a const range.

Template Parameters

R	Range type

Parameters

range	Range to stride over
stride	Stride value

Returns: StrideAdapter for the range

Definition at line 3758 of file functional_adapters.hpp.

                                                       {
  return {std::ranges::cbegin(range), std::ranges::cend(range), stride};
}

◆ StrideAdapterFromRange() [2/2]

template<std::ranges::range R>
requires StrideAdapterRequirements<std::ranges::iterator_t<R>>

constexpr auto helios::utils::StrideAdapterFromRange	(	R &	range,
		size_t	stride
	)		-> StrideAdapter<std::ranges::iterator_t<R>>

constexprnoexcept

Helper function to create a StrideAdapter from a range.

Template Parameters

R	Range type

Parameters

range	Range to stride over
stride	Stride value

Returns: StrideAdapter for the range

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

Definition at line 3743 of file functional_adapters.hpp.

                                             {
  return {std::ranges::begin(range), std::ranges::end(range), stride};
}

◆ TakeAdapterFromRange() [1/2]

template<std::ranges::range R>
requires TakeAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>()))>

constexpr auto helios::utils::TakeAdapterFromRange	(	const R &	range,
		size_t	count
	)		-> TakeAdapter<decltype(std::ranges::cbegin(range))>

constexprnoexcept

Helper function to create a TakeAdapter from a const range.

Template Parameters

R	Range type

Parameters

range	Range to take from
count	Maximum number of elements to yield

Returns: TakeAdapter for the range

Definition at line 3378 of file functional_adapters.hpp.

                                                     {
  return {std::ranges::cbegin(range), std::ranges::cend(range), count};
}

◆ TakeAdapterFromRange() [2/2]

template<std::ranges::range R>
requires TakeAdapterRequirements<std::ranges::iterator_t<R>>

constexpr auto helios::utils::TakeAdapterFromRange	(	R &	range,
		size_t	count
	)		-> TakeAdapter<std::ranges::iterator_t<R>>

constexprnoexcept

Helper function to create a TakeAdapter from a non-const range.

Template Parameters

R	Range type

Parameters

range	Range to take from
count	Maximum number of elements to yield

Returns: TakeAdapter for the range

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

Definition at line 3363 of file functional_adapters.hpp.

                                           {
  return {std::ranges::begin(range), std::ranges::end(range), count};
}

◆ TakeWhileAdapterFromRange() [1/2]

template<std::ranges::range R, typename Pred >
requires TakeWhileAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R&>())), Pred>

constexpr auto helios::utils::TakeWhileAdapterFromRange	(	const R &	range,
		Pred	predicate
	)		-> TakeWhileAdapter<decltype(std::ranges::cbegin(range)), Pred>

constexprnoexcept

Helper function to create a TakeWhileAdapter from a const range.

Template Parameters

R	Range type
Pred	Predicate type

Parameters

range	Range to take from
predicate	Predicate to test elements

Returns: TakeWhileAdapter for the range

Definition at line 3441 of file functional_adapters.hpp.

                                                                {
  return {std::ranges::cbegin(range), std::ranges::cend(range), std::move(predicate)};
}

◆ TakeWhileAdapterFromRange() [2/2]

template<std::ranges::range R, typename Pred >
requires TakeWhileAdapterRequirements<std::ranges::iterator_t<R>, Pred>

constexpr auto helios::utils::TakeWhileAdapterFromRange	(	R &	range,
		Pred	predicate
	)		-> TakeWhileAdapter<std::ranges::iterator_t<R>, Pred>

constexprnoexcept

Helper function to create a TakeWhileAdapter from a non-const range.

Template Parameters

R	Range type
Pred	Predicate type

Parameters

range	Range to take from
predicate	Predicate to test elements

Returns: TakeWhileAdapter for the range

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

Definition at line 3424 of file functional_adapters.hpp.

                                                      {
  return {std::ranges::begin(range), std::ranges::end(range), std::move(predicate)};
}

◆ ZipAdapterFromRange() [1/3]

template<std::ranges::range R1, std::ranges::range R2>
requires ZipAdapterRequirements<decltype(std::ranges::cbegin(std::declval<const R1&>())), decltype(std::ranges::cbegin(std::declval<const R2&>()))>

constexpr auto helios::utils::ZipAdapterFromRange	(	const R1 &	range1,
		const R2 &	range2
	)		-> ZipAdapter<decltype(std::ranges::cbegin(range1)), decltype(std::ranges::cbegin(range2))>

constexprnoexcept

Helper function to create a ZipAdapter from two const ranges.

Template Parameters

R1	First range type
R2	Second range type

Parameters

range1	First range
range2	Second range

Returns: ZipAdapter for the two ranges

Definition at line 3809 of file functional_adapters.hpp.

                                                                                        {
  return {std::ranges::cbegin(range1), std::ranges::cend(range1), std::ranges::cbegin(range2),
          std::ranges::cend(range2)};
}

◆ ZipAdapterFromRange() [2/3]

template<std::ranges::range R1, std::ranges::range R2>
requires ZipAdapterRequirements<std::ranges::iterator_t<R1>, decltype(std::ranges::cbegin(std::declval<const R2&>()))>

constexpr auto helios::utils::ZipAdapterFromRange	(	R1 &	range1,
		const R2 &	range2
	)		-> ZipAdapter<std::ranges::iterator_t<R1>, decltype(std::ranges::cbegin(range2))>

constexprnoexcept

Helper function to create a ZipAdapter from a range and a const range.

Template Parameters

R1	First range type
R2	Second range type

Parameters

range1	First range
range2	Second range

Returns: ZipAdapter for the two ranges

Definition at line 3791 of file functional_adapters.hpp.

                                                                              {
  return {std::ranges::begin(range1), std::ranges::end(range1), std::ranges::cbegin(range2), std::ranges::cend(range2)};
}

◆ ZipAdapterFromRange() [3/3]

template<std::ranges::range R1, std::ranges::range R2>
requires ZipAdapterRequirements<std::ranges::iterator_t<R1>, std::ranges::iterator_t<R2>>

constexpr auto helios::utils::ZipAdapterFromRange	(	R1 &	range1,
		R2 &	range2
	)		-> ZipAdapter<std::ranges::iterator_t<R1>, std::ranges::iterator_t<R2>>

constexprnoexcept

Helper function to create a ZipAdapter from two ranges.

Template Parameters

R1	First range type
R2	Second range type

Parameters

range1	First range
range2	Second range

Returns: ZipAdapter for the two ranges

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

Definition at line 3774 of file functional_adapters.hpp.

                                                                    {
  return {std::ranges::begin(range1), std::ranges::end(range1), std::ranges::begin(range2), std::ranges::end(range2)};
}

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

Namespaces

Classes

Concepts

Enumerations

Functions

Enumeration Type Documentation

◆ DynamicLibraryError

◆ FileError

Function Documentation

◆ ChainAdapterFromRange() [1/4]

◆ ChainAdapterFromRange() [2/4]

◆ ChainAdapterFromRange() [3/4]

◆ ChainAdapterFromRange() [4/4]

◆ ConcatAdapterFromRange() [1/4]

◆ ConcatAdapterFromRange() [2/4]

◆ ConcatAdapterFromRange() [3/4]

◆ ConcatAdapterFromRange() [4/4]

◆ DynamicLibraryErrorToString()

◆ EnumerateAdapterFromRange() [1/2]

◆ EnumerateAdapterFromRange() [2/2]

◆ FileErrorToString()

◆ FilterAdapterFromRange() [1/2]

◆ FilterAdapterFromRange() [2/2]

◆ FromPath()

◆ GetFileExtension()

◆ GetFileName()

◆ InspectAdapterFromRange() [1/2]

◆ InspectAdapterFromRange() [2/2]

◆ JoinAdapterFromRange() [1/2]

◆ JoinAdapterFromRange() [2/2]

◆ MapAdapterFromRange() [1/2]

◆ MapAdapterFromRange() [2/2]

◆ ReadFileToString() [1/2]

◆ ReadFileToString() [2/2]

◆ ReverseAdapterFromRange() [1/2]

◆ ReverseAdapterFromRange() [2/2]

◆ SkipAdapterFromRange() [1/2]

◆ SkipAdapterFromRange() [2/2]

◆ SkipWhileAdapterFromRange() [1/2]

◆ SkipWhileAdapterFromRange() [2/2]

◆ SlideAdapterFromRange() [1/2]

◆ SlideAdapterFromRange() [2/2]

◆ StepByAdapterFromRange() [1/2]

◆ StepByAdapterFromRange() [2/2]

◆ StrideAdapterFromRange() [1/2]

◆ StrideAdapterFromRange() [2/2]

◆ TakeAdapterFromRange() [1/2]

◆ TakeAdapterFromRange() [2/2]

◆ TakeWhileAdapterFromRange() [1/2]

◆ TakeWhileAdapterFromRange() [2/2]

◆ ZipAdapterFromRange() [1/3]

◆ ZipAdapterFromRange() [2/3]

◆ ZipAdapterFromRange() [3/3]