ice Namespace Reference

SPDX-License-Identifier: MIT. More...

Namespaces
namespace	_validate
namespace	_validation
namespace	api
namespace	buffer
namespace	build
namespace	clock
namespace	color
namespace	concepts
namespace	config
namespace	container
namespace	current_thread
namespace	data
namespace	detail
namespace	i18n
namespace	info
namespace	math
namespace	math_detail
namespace	native_aio
namespace	native_file
namespace	os
namespace	path
namespace	profiling
namespace	queue
namespace	stopwatch
namespace	string
namespace	timeline
namespace	timer
namespace	uri
namespace	varstring

Classes
struct	AlignResult
struct	AlignResult< T * >
struct	AllocatorBase
struct	AllocatorBase< true >
class	AllocatorDebugInfo
struct	AllocRequest
struct	AllocResult
struct	Array
	A simple container storing items in continuous memory. More...
struct	AtomicLinkedQueue
struct	AtomicLinkedQueueRange
struct	BaseStringID
	Hashed representation of a ice::String value. More...
struct	BaseStringID< false >
struct	BaseStringID< true >
struct	BasicHeapPath
struct	BasicPath
struct	BasicString
struct	BoolLogic
struct	Buffer
struct	ChunkedAllocRequest
struct	Clock
	Simple object representing a clock by using two timestamps. More...
struct	ClockFrequency
	Represent the current systems clock frequency. Can be used to transform timestamps to time values. More...
class	Config
class	ConfigBuilder
struct	ConfigBuilderValue
struct	const_correct
struct	const_correct< OwnerT const, ValueT >
struct	CustomClock
	A custom clock allows to control the "speed" of calculated time. More...
struct	Data
class	DevUIContext
struct	DevUIContextSetupParams
class	DevUIFrame
class	DevUIWidget
struct	DevUIWidgetInfo
struct	DevUIWidgetState
struct	ErrorCode
struct	ErrorCodeError
struct	ErrorCodeSuccess
class	Expected
class	Expected< ice::ErrorCode, ice::ErrorCode >
struct	FlagLogic
struct	ForwardAllocator
struct	ForwardAllocatorParams
struct	FromCharsResult
class	Generator
class	GeneratorPromise
struct	HashMap
	A Map container designed for storing values using hashed values. More...
struct	HeapPathString
struct	HeapString
struct	HeapVarString
class	HostAllocator
struct	I18NCoreModule
class	I18NReference
class	I18NResolver
struct	I18NString
class	IDevUIWidget
struct	Implements
struct	InterfaceSelector
struct	InterfaceSelectorOf
struct	isize
	Represents a signed size value on the given platform. More...
struct	LogModule
struct	LogSinkMessage
struct	LogTagDefinition
struct	make_unique_tuple_helper
struct	make_unique_tuple_helper< std::tuple< Ts... > >
class	ManualResetBarrier
class	ManualResetEvent
struct	member_info
struct	member_info< Ret(Class::*)(Args...) noexcept >
struct	member_info< Ret(Class::*)(Args...)>
struct	member_info< Value Class::* >
struct	meminfo
struct	Memory
class	Module
	Base class for modules that will automatically register them to be loaded by the module manager. More...
struct	ModuleAPI
	Stores information about a single API entry. More...
struct	ModuleInfo
	Stores information of module load and unload functions. More...
struct	ModuleNegotiatorAPI
	Negotiation API used to register and query modules for their APIs. More...
class	ModuleNegotiatorBase
	Helper type over the ModuleNegotiatorAPI type. More...
class	ModuleNegotiatorTagged
struct	ModuleQuery
class	ModuleRegister
	Type to manage loading and unloading of modules and their APIs. More...
struct	ModulesEntry
	Helper type to register modules globally. More...
struct	MultiHashMap
struct	ncount
struct	ncount_invalid_t
struct	nindex
struct	nindex_invalid_t
class	NullAllocator
struct	nvalue
struct	ParamDefinition
	Basic information for each command line parameter. More...
class	ParamInstance
	Class for global defined parameter instances of simple native types. More...
struct	ParamInstanceBase
	Base class for global defined parameter instances. More...
class	ParamInstanceCustom
	Class for global defined parameter instances of custom parameter types. More...
struct	PathString
struct	ProxyAllocator
class	Ptr
class	Ptr< Object const >
struct	Queue
	A double ended queue, build on a circular buffer. More...
struct	ref16
	Holds 'offset' and 'size' fields (u16) to access data stored in a buffer-like object. More...
struct	ref32
	Holds 'offset' and 'size' fields (u32) to access data stored in a buffer-like object. More...
struct	ref8
	Holds 'offset' and 'size' fields (u8) to access data stored in a buffer-like object. More...
struct	RefCountStats
struct	RingAllocator
struct	RingAllocatorParams
class	ScopedTaskContainer
struct	Shard
struct	ShardContainer
struct	ShardID
struct	ShardPayloadID
struct	SnakeAllocator
struct	SnakeAllocatorParams
struct	Span
	A view into an array of objects laid out in contiguous memory. More...
struct	StackAllocator
struct	StaticString
struct	Stopwatch
struct	StringID_Hash
	Internal hash type representing the hashed string value. More...
struct	StrongNumeric
	Type tag to enable utility functions for strongly typed numeric values. More...
struct	StrongValue
	Type tag to enable utility functions for strongly typed values. More...
struct	SystemClock
	A system clock provides access to the actual time on the running system. More...
struct	TaggedStrongValue
	Type tag to enable utility functions for strongly typed values across multiple types. More...
class	Task
struct	TaskAwaitableBase
struct	TaskAwaitableCustomResumer
struct	TaskAwaitableParams
struct	TaskAwaitableResult
struct	TaskCancelationToken
class	TaskCheckpoint
class	TaskCheckpointGate
struct	TaskContainer
struct	TaskExpected
struct	TaskExpectedPromise
struct	TaskFlags
struct	TaskHandle
	Special handle accessing task information at runtime. More...
struct	TaskInfo
struct	TaskInfoPromise
struct	TaskProfilingInfo
struct	TaskProfilingInfo< true >
class	TaskPromise
class	TaskPromise< T & >
class	TaskPromise< void >
struct	TaskPromiseBase
class	TaskQueue
class	TaskScheduler
struct	TaskStage
struct	TaskStageAwaitable
struct	TaskStageAwaitable< void >
class	TaskThread
struct	TaskThreadInfo
class	TaskThreadPool
struct	TaskThreadPoolCreateInfo
struct	TaskTokenBase
struct	TaskTransaction
struct	TaskTransactionTracker
struct	Timeline
struct	Timer
struct	Timestamp
	Represents platform native timestamp with undefined representation. More...
struct	Tms
	Represents time interval of milliseconds. More...
struct	Tns
	Represents time interval of nanoseconds. More...
struct	Ts
	Represents time interval of seconds. More...
struct	tuples_merged
struct	tuples_merged< std::tuple< FirstTypes... >, std::tuple< SecondTypes... >, Tail... >
struct	tuples_merged< std::tuple< Types... > >
struct	Tus
	Represents time interval of microseconds. More...
struct	unique_tuple
struct	unique_tuple< std::tuple< Ts... >, U, Us... >
struct	UniquePtr
struct	usize
	Represents a unsigned size value on the given platform. More...
struct	VarStringBase

Concepts
concept	AllowedAsShardPayloadID
concept	BoolType
concept	FlagAllValue
concept	FlagType
concept	HasDataRepresentation
concept	HasShardPayloadID
concept	MakeUniqueConstructorAvailable
concept	SameTaggedTypes
	Concept used to ensure two strong types have the same tag type.
concept	StrongNumericType
	Concept used to determine if a struct is considerd a strong number wrapper.
concept	StrongValueType
	Concept used to determine if a struct is considerd a strong type wrapper.
concept	TaggedStrongValueType
	Concept used to determine if a struct is considerd a tagged strong type wrapper.
concept	TaskFlagType
concept	TimeType
concept	TrivialContainerLogicAllowed
	A concept that ensures only types that can be trivially copyable can be 'forced' to use trifial Logic.

Typedefs
template<typename T, ice::u32 Size>
using	StaticArray = std::array<T, Size>
using	String = ice::BasicString<char>
using	WString = ice::BasicString<wchar_t>
using	VarStringTag = struct _tagVarString
using	VarString = VarStringBase<char>
template<typename T>
using	clear_type_t = std::remove_pointer_t<std::remove_reference_t<std::remove_cv_t<T>>>
template<typename T>
using	clean_type = clear_type_t<T>
template<typename Member>
using	member_class_type_t = typename member_info<Member>::class_type
template<typename Member>
using	member_result_type_t = typename member_info<Member>::result_type
template<typename Member, ice::u64 Idx>
using	member_arg_type_t = std::tuple_element_t<Idx, typename member_info<Member>::argument_types>
template<typename T>
using	StrongNumericBase = typename ice::detail::ExtractMemberType<decltype(&T::value)>::Type
using	StringID
	\copy ice::BaseStringID.
using	StringID_Arg
	Argument type used to pass ice::StringID values to functions.
using	utf8 = char8_t
using	utf16 = char16_t
using	utf32 = char32_t
using	wchar = wchar_t
using	f32 = float
using	f64 = double
using	i8 = std::int8_t
using	i16 = std::int16_t
using	i32 = std::int32_t
using	i64 = std::int64_t
using	u8 = std::uint8_t
using	u16 = std::uint16_t
using	u32 = std::uint32_t
using	u64 = std::uint64_t
using	uptr = std::uintptr_t
template<typename OwnerT, typename ValueT>
using	const_correct_t = typename ice::const_correct<OwnerT, ValueT>::type
template<typename... Tuples>
using	tuples_merged_t = typename ice::tuples_merged<Tuples...>::type
template<typename... Ts>
using	unique_tuple_t = typename ice::unique_tuple<std::tuple<>, Ts...>::type
template<typename T>
using	make_unique_tuple = typename make_unique_tuple_helper<T>::type
using	FnDevUIAlloc = void*(*)(size_t size, void* userdata) noexcept
using	FnDevUIDealloc = void(*)(void* size, void* userdata) noexcept
using	FnDevUIContextSetupCallback
using	LogSinkFn = void(*)(void* userdata, ice::LogSinkMessage const& message) noexcept
using	StackAllocator_1024 = StackAllocator<1024_B>
using	StackAllocator_2048 = StackAllocator<2048_B>
using	Allocator = ice::AllocatorBase<ice::build::is_debug || ice::build::is_develop>
template<typename T>
using	UniquePtrCustomDeleter = void(T*) noexcept
using	FnModuleLoad = void (ice::Allocator*, ice::ModuleNegotiatorAPIContext*, ice::ModuleNegotiatorAPI*)
using	FnModuleUnload = void (ice::Allocator*)
using	FnModuleSelectAPI = bool (ice::StringID_Hash, ice::u32, ice::ModuleAPI*)
template<typename T>
using	ProcAPIQuickRegisterFunc = void(*)(T& out_api) noexcept
using	FnCustomResumerFunc = bool(*)(void* userdata, ice::TaskAwaitableBase const& awaitable) noexcept
using	FnTaskQueueFilter = bool(*)(ice::TaskAwaitableParams params, void* userdata) noexcept
using	TaskFlagBaseType = ice::u32
	Base type required for an Enum to be a valid TaskFlag enumeration.
using	TaskThreadProcedure = auto(void* userdata, ice::TaskQueue&) noexcept -> ice::u32
template<typename Type = void>
using	coroutine_handle = std::coroutine_handle<Type>
using	suspend_always = std::suspend_always
using	suspend_never = std::suspend_never
using	Color = ice::color::OkLCH
using	ShaderColor = ice::color::LRGB
using	RefCounted = ice::detail::RefCounted
using	Result = ice::Expected<ice::ErrorCode>
using	Params = ice::UniquePtr<ParamsInternal> const
using	ParamsCustomCallback = bool(*)(void* userdata, ice::Span<ice::String const> results) noexcept
using	Path = ice::BasicPath<char>
using	HeapPath = ice::BasicHeapPath<char>

Enumerations
enum class	ContainerLogic : ice::u8 { Trivial , Complex }
	The logic implemented by a collectiont type when working with data. (Copying, Moving, Removing, etc.). More...
enum class	LogSeverity : ice::u32 {   Critical = 0x1 , Retail , Error , Warning ,   Info , Verbose , Debug , None = 0x0 ,   All = 0xffff'ffff }
enum class	LogSinkID : uint8_t { Invalid = 0 }
enum class	LogTag : ice::u64 {   None = 0x0 , Core = 0x1ull << 0 , System = Core << 1 , Module = Core << 2 ,   Engine = Core << 3 , Asset = Core << 4 , Game = Core << 5 , Tool = Core << 24 }
enum class	ualign : ice::u32 {   invalid = 0 , b_1 = 1 , b_2 = 2 , b_4 = 4 ,   b_8 = 8 , b_16 = 16 , b_32 = 32 , b_64 = 64 ,   b_128 = 128 , b_256 = 256 , b_512 = 512 , b_1024 = 1024 ,   b_2048 = 2048 , b_default = ice::build::is_x64 ? b_16 : b_8 }
enum class	TaskAwaitableModifier : ice::u32 {   Unused = 0x0 , PriorityFlags = 0x8000'0000 , DelayedExecution = 0x4000'0000 , CustomValue = 0x2000'0000 ,   CustomResumer = 0x1000'0000 }
enum class	TaskState : ice::u8 {   None , Invalid = None , Created = 0x01 , Running = 0x02 ,   Suspended = 0x04 , Succeeded = 0x08 , Canceled = 0x10 , Failed = 0x20 ,   All = Created | Running | Suspended | Succeeded | Canceled | Failed }
	All states a task can be in. More...
enum class	ConfigValueFlags : ice::u8 { None , AllowImplicitCasts = 0x01 }
enum class	ConfigValueType : ice::u8 {   Invalid , Bool , U8 , U16 ,   U32 , U64 , S8 , S16 ,   S32 , S64 , F32 , F64 ,   String , Blob , Table , Object }
enum class	ColorSpace : ice::u8 { SRGB }
enum class	ColorFormat : ice::u8 {   OkLCH , OkLAB , LinearRGB , StandardRGB ,   OkLCHu8 , LinearRGBu8 }
enum class	ParamFlags : ice::u32 {   None = 0x00'00 , IsRequired = 0x00'01 , AllowExtraArgs = 0x00'02 , NoExtraArgs = 0x00'04 ,   TakeFirst = 0x01'00 , TakeLast = 0x02'00 , TakeAll = 0x04'00 , ValidateFile = 0x10'00 ,   ValidateDirectory = 0x20'00 , ValidatePath = ValidateFile | ValidateDirectory , All }
	Additional flags altering command line parameter behaviors. More...
enum class	CaseSensitive : bool { No , Yes }
enum class	CompareResult : ice::i8 { Smaller = -1 , Equal = 0 , Larger = 1 }

Functions
template<typename Type, ice::ContainerLogic Logic>
auto	data_view (ice::Array< Type, Logic > const &arrarr) noexcept -> ice::Data=delete
constexpr auto	hash (ice::HeapString<> const &value) noexcept -> ice::u64
template<typename Type, typename Fn>
auto	accumulate_over (ice::Span< Type > objects, Fn &&fn) noexcept -> ice::u32
template<typename T, typename U = T> requires (std::convertible_to<T, U>)
constexpr auto	lower_bound (ice::Span< T > values, U const &value) noexcept -> ice::u32
template<typename T, typename Comp, typename U = T> requires (std::convertible_to<T, U>)
constexpr auto	lower_bound (ice::Span< T > values, U const &value, Comp &&comp) noexcept -> ice::u32
template<typename T, typename U = T> requires (std::convertible_to<T, U>)
constexpr auto	upper_bound (ice::Span< T > values, U const &value) noexcept -> ice::u32
template<typename T, typename Comp, typename U = T> requires (std::convertible_to<T, U>)
constexpr auto	upper_bound (ice::Span< T > values, U const &value, Comp &&comp) noexcept -> ice::u32
template<typename T, typename U = T> requires (std::convertible_to<T, U>)
constexpr bool	binary_search (ice::Span< T > values, U const &value, ice::u32 &out_index) noexcept
template<typename T, typename Comp, typename U = T> requires (std::convertible_to<T, U>)
constexpr bool	binary_search (ice::Span< T > values, U const &value, Comp &&comp, ice::u32 &out_index) noexcept
template<typename T, typename U = T> requires (std::convertible_to<T, U>)
constexpr bool	search (ice::Span< T > values, U const &value, ice::u32 &out_index) noexcept
template<typename T, typename Comp, typename U = T>
constexpr bool	search (ice::Span< T > values, U const &value, Comp &&comp, ice::u32 &out_index) noexcept
template<typename T>
void	sort (ice::Span< T > span) noexcept
template<typename T, typename Pred>
void	sort (ice::Span< T > span, Pred &&pred) noexcept
template<typename K, typename V, typename Pred>
void	sort (ice::Span< K > keys, ice::Span< V > values, Pred &&pred) noexcept
template<typename T>
constexpr auto	constexpr_sort_stdarray (T const &arrarr, ice::u32 start_offset=0) noexcept -> T
template<typename K, typename Pred>
void	sort_indices (ice::Span< K > keys, ice::Span< ice::u32 > indices, Pred &&pred) noexcept
template<typename Node, typename Pred>
auto	sort_linked_list (Node *left_list, ice::u32 size, Pred &&pred) noexcept -> Node *
template<typename T, typename Comp, typename... U>
constexpr bool	search_with (ice::Span< T > values, Comp &&comp, ice::u32 &out_index, U const &... params) noexcept
template<typename Key, typename Pred, typename... Values> requires ice::concepts::ComparisonFunction<Pred, Key, Key>
void	sort_many (ice::Span< Key > keys, Pred &&pred, ice::Span< Values >... values) noexcept
template<typename T>
	Span (ice::Span< T > &&) noexcept -> Span< T >
template<typename T>
	Span (ice::Span< T > const &) noexcept -> Span< T >
template<typename T, ContainerLogic Logic, template< typename, ContainerLogic > typename Container>
	Span (Container< T, Logic > const &) noexcept -> Span< T >
template<typename T, ice::u64 Size>
	Span (T(&)[Size]) noexcept -> Span< T >
template<typename Type, size_t Size>
static constexpr auto	make_span (std::array< Type, Size > &std_array) noexcept -> Span< Type >
template<typename Type, size_t Size>
static constexpr auto	make_span (std::array< Type, Size > const &std_array) noexcept -> Span< Type const >
template<typename Type, size_t Size>
constexpr auto	make_span (std::array< Type, Size > &std_array) noexcept -> Span< Type >
template<typename Type, size_t Size>
constexpr auto	make_span (std::array< Type, Size > const &std_array) noexcept -> Span< Type const >
template<ice::u32 Capacity = 12>
constexpr auto	stringid (ice::StaticString< Capacity, char > value) noexcept -> ice::StringID
constexpr auto	operator""_str (char const *buffer, size_t size) noexcept -> ice::BasicString< char >
template<typename CharType, typename T> requires ice::concepts::RODataObject<T>
constexpr auto	string_from_data (T ro_data, ice::nindex offset, ice::ncount size) noexcept -> ice::BasicString< CharType >
template<typename CharType, typename T> requires ice::concepts::RODataObject<T>
constexpr auto	string_from_data (T ro_data) noexcept -> ice::BasicString< CharType >
constexpr auto	hash (ice::String value) noexcept -> ice::u64
constexpr auto	hash32 (ice::String value) noexcept -> ice::u32
constexpr auto	stringid (ice::String value) noexcept -> ice::StringID
constexpr auto	operator""_count (unsigned long long value) noexcept -> ice::ncount
constexpr auto	operator""_index (unsigned long long value) noexcept -> ice::nindex
template<typename T, ice::u32 Size>
constexpr auto	count (T const (&)[Size]) noexcept -> ice::u32
template<typename T, typename U = T> requires (std::convertible_to<U, T>)
constexpr auto	value_or_default (T value, U default_value) noexcept -> T=delete
template<typename T, typename U = T> requires (std::convertible_to<U*, T*>)
constexpr auto	value_or_default (T *value, U *default_value) noexcept -> T *
template<typename T, typename U = T> requires (std::convertible_to<U, T> && std::is_arithmetic_v<T>)
constexpr auto	value_or_default (T value, U &&default_value) noexcept -> T
template<typename T>
constexpr auto	to_const (T *value) noexcept -> T const *
constexpr auto	operator""_Ts (long double time) noexcept -> ice::Ts
constexpr auto	operator""_Ts (unsigned long long time) noexcept -> ice::Ts
constexpr auto	operator""_Tms (unsigned long long time) noexcept -> ice::Tms
constexpr auto	operator""_Tus (unsigned long long time) noexcept -> ice::Tus
constexpr auto	operator""_Tns (unsigned long long time) noexcept -> ice::Tns
constexpr auto	operator<=> (ice::TimeType auto left, TimeType auto right) noexcept
constexpr auto	operator+ (ice::TimeType auto left, TimeType auto right) noexcept
constexpr auto	operator- (ice::TimeType auto left, TimeType auto right) noexcept
constexpr auto	operator== (ice::TimeType auto left, TimeType auto right) noexcept
template<ice::BoolType T>
constexpr auto	operator! (T left) noexcept -> T
template<ice::FlagType T>
constexpr auto	operator| (T left, T right) noexcept -> T
template<ice::FlagType T>
constexpr auto	operator|= (T &left, T right) noexcept -> T &
template<ice::FlagType T>
constexpr auto	operator& (T left, T right) noexcept -> T
template<ice::FlagType T>
constexpr auto	operator&= (T &left, T right) noexcept -> T &
template<ice::FlagType T>
constexpr auto	operator~ (T left) noexcept -> T
template<ice::FlagType T>
constexpr bool	has_all (T value, T expected_flags) noexcept
template<ice::FlagType T>
constexpr bool	has_any (T value, T expected_flags) noexcept
template<ice::FlagType T>
constexpr bool	has_none (T value, T expected_flags) noexcept
template<typename T> requires ice::StrongNumericType<T>
constexpr auto	operator== (T left, T right) noexcept -> bool
template<typename T> requires ice::StrongNumericType<T>
constexpr auto	operator<=> (T left, T right) noexcept
template<typename T> requires StrongNumericType<T>
constexpr auto	operator+ (T left, T right) noexcept -> T
template<typename T> requires StrongNumericType<T>
constexpr auto	operator- (T left, T right) noexcept -> T
template<typename T> requires StrongNumericType<T>
constexpr auto	operator- (T left) noexcept -> T
template<typename T> requires StrongNumericType<T>
constexpr auto	operator* (T left, T right) noexcept -> T
template<typename T> requires StrongNumericType<T>
constexpr auto	operator* (T left, ice::StrongNumericBase< T > right) noexcept -> T
template<typename T> requires StrongNumericType<T>
constexpr auto	operator/ (T left, T right) noexcept -> T
template<typename T> requires StrongNumericType<T>
constexpr auto	operator/ (T left, ice::StrongNumericBase< T > right) noexcept -> T
template<typename T> requires StrongNumericType<T>
constexpr auto	operator+= (T &left, T right) noexcept -> T &
template<typename T> requires StrongNumericType<T>
constexpr auto	operator-= (T &left, T right) noexcept -> T &
template<typename T> requires StrongNumericType<T>
constexpr auto	operator*= (T &left, T right) noexcept -> T &
template<typename T> requires StrongNumericType<T>
constexpr auto	operator*= (T &left, ice::StrongNumericBase< T > right) noexcept -> T &
template<typename T> requires StrongNumericType<T>
constexpr auto	operator/= (T &left, T right) noexcept -> T &
template<typename T> requires StrongNumericType<T>
constexpr auto	operator/= (T &left, ice::StrongNumericBase< T > right) noexcept -> T &
template<typename T> requires ice::StrongValueType<T>
constexpr bool	operator== (T left, T right) noexcept
template<typename T, typename U> requires ice::SameTaggedTypes<T, U>
constexpr bool	operator== (T left, U right) noexcept
constexpr bool	operator== (ErrorCode lhs, ErrorCode rhs) noexcept
constexpr bool	operator== (ErrorCode lhs, bool value) noexcept
constexpr bool	operator== (ErrorCodeSuccess lhs, ErrorCodeSuccess) noexcept
constexpr bool	operator== (ErrorCode lhs, ErrorCodeSuccess) noexcept
constexpr bool	operator== (ErrorCodeError lhs, ErrorCodeError) noexcept
constexpr bool	operator== (ErrorCode lhs, ErrorCodeError) noexcept
constexpr bool	operator== (ErrorCodeSuccess lhs, ErrorCodeError) noexcept
template<typename T>
constexpr auto	hash (T value) noexcept -> ice::u64
template<>
constexpr auto	hash (std::u8string_view value) noexcept -> ice::u64
template<>
constexpr auto	hash (ice::utf8 const *value) noexcept -> ice::u64
template<>
constexpr auto	hash (std::string_view value) noexcept -> ice::u64
template<>
constexpr auto	hash (char const *value) noexcept -> ice::u64
template<typename T>
constexpr auto	hash32 (T value) noexcept -> uint32_t
template<>
constexpr auto	hash32 (std::u8string_view value) noexcept -> ice::u32
template<>
constexpr auto	hash32 (ice::utf8 const *value) noexcept -> ice::u32
template<>
constexpr auto	hash32 (std::string_view value) noexcept -> ice::u32
template<>
constexpr auto	hash32 (char const *value) noexcept -> ice::u32
template<typename T>
constexpr auto	hash_from_ptr (T *ptr) noexcept -> ice::u64
template<>
constexpr auto	hash (std::u8string_view value) noexcept -> ice::u64
template<>
constexpr auto	hash (ice::utf8 const *value) noexcept -> ice::u64
template<>
constexpr auto	hash (std::string_view value) noexcept -> ice::u64
template<>
constexpr auto	hash (char const *value) noexcept -> ice::u64
template<>
constexpr auto	hash32 (std::u8string_view value) noexcept -> ice::u32
template<>
constexpr auto	hash32 (ice::utf8 const *value) noexcept -> ice::u32
template<>
constexpr auto	hash32 (std::string_view value) noexcept -> ice::u32
template<>
constexpr auto	hash32 (char const *value) noexcept -> ice::u32
constexpr auto	shardid (ice::Shard shard) noexcept -> ice::ShardID
	Returns the ice::ShardID value of a shard.
constexpr auto	shardid (std::string_view definition) noexcept -> ice::ShardID
	Creates a ice::ShardID value from a utf8 string.
constexpr auto	shard (ice::ShardID id) noexcept -> ice::Shard
	Creates a ice::Shard value from ice::ShardID. Clears the payload ID from the created shard.
template<typename T>
constexpr auto	shard (std::string_view definition, T value)
	Creates a ice::Shard value from a utf8 string and the given value.
template<typename T>
constexpr auto	shard (ice::ShardID id, T payload) noexcept -> ice::Shard
	Creates a ice::Shard value from ice::ShardID and the given value.
template<typename T>
constexpr bool	shard_inspect (ice::Shard shard, T &payload) noexcept
	Tries to read the value from the given shard.
template<typename T>
constexpr auto	shard_shatter (ice::Shard shard, T fallback) noexcept -> T
	Reads the value from the given shard or returns the fallback value.
constexpr auto	operator""_shard (ice::utf8 const *str, size_t size) noexcept -> ice::Shard
constexpr auto	operator""_shardid (ice::utf8 const *str, size_t size) noexcept -> ice::ShardID
constexpr auto	shard_payloadid (std::string_view sv) noexcept -> ice::ShardPayloadID
constexpr auto	operator""_shardid (char const *str, size_t size) noexcept -> ice::ShardID
template<typename T> requires ice::HasShardPayloadID<T>
constexpr auto	shard (std::string_view definition, T value) noexcept -> ice::Shard
	Creates a ice::Shard value from a utf8 string and the given value.
template<typename T> requires ice::HasShardPayloadID<T>
constexpr auto	shard (ice::ShardID id, T value) noexcept -> ice::Shard
	Creates a ice::Shard value from ice::ShardID and the given value.
constexpr auto	operator""_shard (char const *str, size_t size) noexcept -> ice::Shard
template<typename T> requires ice::HasShardPayloadID<T>
constexpr auto	operator| (ice::Shard shard, T payload) noexcept -> ice::Shard
template<typename T> requires ice::HasShardPayloadID<T>
constexpr auto	operator| (ice::ShardID shardid, T payload) noexcept -> ice::Shard
constexpr auto	operator== (ice::ShardID left, ice::ShardID right) noexcept -> bool
constexpr auto	operator== (ice::Shard left, ice::Shard right) noexcept -> bool
constexpr auto	operator== (ice::Shard left, ice::ShardID right) noexcept -> bool
template<typename T> requires ice::HasShardPayloadID<T>
constexpr bool	shard_inspect (ice::Shard shard, T &value) noexcept
	Tries to read the value from the given shard.
template<typename T> requires ice::HasShardPayloadID<T>
constexpr auto	shard_shatter (ice::Shard shard, T fallback) noexcept -> T
	Reads the value from the given shard or returns the fallback value.
template<>
constexpr auto	hash (ice::ShardID shardid) noexcept -> ice::u64
constexpr auto	hash32 (ice::ShardID shardid) noexcept -> ice::u32
constexpr auto	stringid (std::string_view value) noexcept
constexpr auto	stringid (const char *string, size_t size) noexcept
constexpr auto	stringid_hint (ice::BaseStringID< false > val) noexcept -> std::string_view
constexpr auto	stringid_hint (ice::BaseStringID< true > const &val) noexcept -> std::string_view
template<bool HasDebugInfo>
constexpr auto	stringid_hash (ice::BaseStringID< HasDebugInfo > val) noexcept -> ice::detail::stringid_type_v3::StringID_Hash
constexpr auto	hash (ice::StringID_Hash sid_hash) noexcept -> ice::u64
constexpr auto	hash (ice::StringID_Arg value) noexcept -> ice::u64
constexpr auto	operator""_sid (char const *str, size_t len) noexcept
constexpr auto	operator""_sid_hash (char const *str, size_t len) noexcept
constexpr auto	operator<=> (ice::StringID_Arg left, ice::StringID_Arg right) noexcept
template<typename Left, typename Right = Left>
constexpr auto	equal (Left &&left, Right &&right) noexcept -> bool
template<typename Left, typename Right = Left>
constexpr auto	less (Left const &left, Right const &right) noexcept -> bool
template<typename Field, typename Class>
constexpr auto	offset_of (Field Class::*member) noexcept -> ice::uptr
bool	devui_available () noexcept
void	devui_setup_mainmenu (ice::Span< ice::String > categories) noexcept
auto	devui_trait_name () noexcept -> ice::StringID
bool	devui_register_widget (ice::DevUIWidget *widget, ice::DevUIWidget *owning_widget=nullptr) noexcept
bool	devui_remove_widget (ice::DevUIWidget *widget) noexcept
bool	devui_context_setup_default (ice::StringID_Arg context_name, ice::DevUIContextSetupParams const &params, void *userdata) noexcept
bool	devui_setup_context (ice::ModuleQuery const &query, ice::FnDevUIContextSetupCallback callback=ice::devui_context_setup_default, void *userdata=nullptr) noexcept
auto	create_devui_context (ice::Allocator &alloc, ice::ModuleQuery &query) noexcept -> ice::UniquePtr< ice::DevUIContext >
constexpr auto	operator""_i18n (char const *text, size_t size) noexcept -> I18NReference
void	log_module_init (ice::Allocator &alloc, ice::ModuleNegotiatorBase const &negotiator) noexcept
auto	log_module_register_sink (LogSinkFn fn_sink, void *userdata) noexcept -> ice::LogSinkID
void	log_module_unregister_sink (ice::LogSinkID sink_id) noexcept
constexpr auto	create_log_tag (LogTag base_tag, ice::String name) noexcept -> LogTagDefinition
constexpr auto	create_log_tag (LogTagDefinition const &base_tag_def, ice::String name) noexcept -> LogTagDefinition
void	log_tag_register (ice::LogTagDefinition tag_def) noexcept
void	log_tag_enable (ice::LogTag tag, bool enabled=true) noexcept
auto	alloc (ice::usize size) noexcept -> ice::AllocResult
void	release (void *pointer) noexcept
auto	alloc_aligned (ice::usize size, ice::ualign alignment) noexcept -> ice::AllocResult
void	release_aligned (void *pointer) noexcept
auto	memcpy (void *dest, void const *source, ice::usize size) noexcept -> void *
auto	memcpy (void *dest, ice::Data source) noexcept -> void *
auto	memcpy (ice::Memory memory, ice::Data data) noexcept -> ice::Memory
auto	memset (ice::Memory memory, ice::u8 value) noexcept -> ice::Memory
bool	is_aligned (void const *ptr, ice::ualign alignment) noexcept
bool	is_aligned (ice::u32 val, ice::ualign alignment) noexcept
template<typename T> requires std::is_pointer_v<T> || std::is_same_v<T, ice::usize> || std::is_integral_v<T>
constexpr auto	align_to (T value, ice::ualign alignment) noexcept -> ice::AlignResult< T >
auto	data_copy (ice::Allocator &alloc, ice::Data data) noexcept -> ice::Memory
auto	ptr_adv (void *pointer, ice::usize offset, ice::ualign align) noexcept -> void *
auto	ptr_adv (void const *pointer, ice::usize offset, ice::ualign align) noexcept -> void const *
auto	ptr_add (void *pointer, ice::usize offset) noexcept -> void *
auto	ptr_add (void const *pointer, ice::usize offset) noexcept -> void const *
auto	ptr_sub (void *pointer, ice::usize offset) noexcept -> void *
auto	ptr_sub (void const *pointer, ice::usize offset) noexcept -> void const *
auto	ptr_distance (void const *ptr_from, void const *ptr_to) noexcept -> ice::usize
auto	ptr_offset (void const *ptr_from, void const *ptr_to) noexcept -> ice::isize
template<typename Type>
auto	data_view (Type const &var) noexcept
template<typename Type, ice::usize::base_type Size>
constexpr auto	data_view (Type const(&var)[Size]) noexcept
auto	ptr_add (ice::Data mem, ice::usize offset) noexcept -> ice::Data
constexpr auto	operator* (ice::meminfo info, ice::u64 count) noexcept -> ice::meminfo
	Multypling ice::meminfo by a scalar changes the size but keeps the alignment.
constexpr auto	operator+= (ice::meminfo &left, ice::meminfo right) noexcept -> ice::usize
	Adding two ice::meminfo values changes the size and and alignment.
template<typename T, typename... Args>
auto	mem_construct_at (void *memory_ptr, Args &&... args) noexcept -> T *
template<typename T, typename... Args>
auto	mem_construct_at (ice::Memory memory, Args &&... args) noexcept -> T *
template<typename T>
auto	mem_move_construct_at (void *memory_ptr, T &&other) noexcept -> T *
template<typename T>
auto	mem_move_construct_at (ice::Memory memory, T &&other) noexcept -> T *
template<typename T>
auto	mem_copy_construct_at (ice::Memory memory, T const &other) noexcept -> T *
template<typename T>
auto	mem_default_construct_n_at (ice::Memory memory, ice::u64 count) noexcept -> T *
template<typename T>
auto	mem_move_construct_n_at (ice::Memory memory, T *objects, ice::u64 count) noexcept -> T *
template<typename T>
auto	mem_move_n_to (T *target_objects, T *objects, ice::u64 count) noexcept -> T *
template<typename T>
auto	mem_copy_construct_n_at (ice::Memory memory, T const *objects, ice::u64 count) noexcept -> T *
template<typename T, typename ItT>
auto	mem_copy_construct_it_at (ice::Memory memory, ItT begin, ItT end) noexcept -> T *
template<typename T>
void	mem_destruct_at (T *location) noexcept
template<typename T>
void	mem_destruct_n_at (T *location, ice::u64 count) noexcept
constexpr auto	data_view (ice::Memory memory) noexcept -> ice::Data
template<typename T> requires (std::is_array_v<T> == false && std::is_pointer_v<T> == false)
constexpr auto	memory_from (T &object) noexcept -> ice::Memory
auto	ptr_adv (ice::Memory mem, ice::meminfo meminfo) noexcept -> ice::Memory
auto	ptr_adv (ice::Memory mem, ice::usize offset, ice::ualign align) noexcept -> ice::Memory
auto	ptr_add (ice::Memory mem, ice::usize offset) noexcept -> ice::Memory
constexpr auto	operator""_B (unsigned long long v) noexcept -> ice::usize
constexpr auto	operator""_KiB (unsigned long long v) noexcept -> ice::usize
constexpr auto	operator""_MiB (unsigned long long v) noexcept -> ice::usize
constexpr auto	operator- (ice::usize left, ice::usize right) noexcept -> ice::isize
constexpr auto	operator-= (ice::usize &left, ice::usize right) noexcept -> ice::usize &=delete
constexpr auto	operator- (ice::usize left) noexcept -> ice::isize
constexpr auto	operator== (ice::usize left, ice::isize right) noexcept -> bool
constexpr auto	operator+ (ice::usize left, ice::isize right) noexcept -> ice::isize
constexpr auto	operator- (ice::usize left, ice::isize right) noexcept -> ice::isize
constexpr auto	operator+ (ice::isize left, ice::usize right) noexcept -> ice::isize
constexpr auto	operator- (ice::isize left, ice::usize right) noexcept -> ice::isize
constexpr auto	operator% (ice::usize left, ice::ualign right) noexcept -> ice::usize
constexpr auto	operator% (ice::isize left, ice::ualign right) noexcept -> ice::isize
constexpr auto	operator<=> (ice::usize left, ice::isize right) noexcept
constexpr auto	operator<=> (ice::isize left, ice::usize right) noexcept
template<typename T, typename... Args>
auto	make_unique (ice::Allocator &alloc, Args &&... args) noexcept -> ice::UniquePtr< T >
template<typename T>
auto	make_unique (ice::UniquePtrCustomDeleter< T > *fn_deleter, T *instanced_object) noexcept -> ice::UniquePtr< T >
constexpr auto	mem_max_capacity (ice::usize element_size, ice::usize memory_space) noexcept -> ice::u64
template<typename T>
constexpr auto	mem_max_capacity (ice::usize memory_space) noexcept -> ice::u64
auto	load_global_modules (ice::Allocator &alloc, ice::ModuleRegister &modules_register) noexcept -> ice::u32
	Loads all modules available in the current executable.
auto	create_default_module_register (ice::Allocator &alloc, bool load_global_modules=true) noexcept -> ice::UniquePtr< ice::ModuleRegister >
	Creates a default module register.
auto	resume_on (ice::TaskScheduler &scheduler) noexcept
auto	await_tasks (ice::Span< ice::Task<> > tasks) noexcept -> ice::Task<>
template<typename T>
auto	await_on (ice::Task< T > task, ice::TaskScheduler &resumer) noexcept -> ice::Task< T >
template<typename T>
auto	await_scheduled (ice::Task< T > task, ice::TaskScheduler &scheduler) noexcept -> ice::Task< T >
template<typename T>
auto	await_scheduled_on (ice::Task<> task, ice::TaskScheduler &scheduler, ice::TaskScheduler &resumer) noexcept -> ice::Task< T >
template<typename T>
auto	wait_for_result (ice::Task< T > task) noexcept -> T
template<typename T>
void	wait_for_result (ice::Task< T > task, T &out_result) noexcept
template<typename T>
void	wait_for_result (ice::Span< ice::Task< T > > tasks, ice::Span< T > out_results) noexcept
template<typename T>
void	wait_for_result_scheduled (ice::Task< T > task, ice::TaskScheduler &scheduler, T &out_result) noexcept
template<typename T>
void	wait_for_result_scheduled (ice::Span< ice::Task< T > > tasks, ice::TaskScheduler &scheduler, ice::Span< T > out_results) noexcept
template<typename T>
auto	wait_for_expected (ice::TaskExpected< T > task) noexcept -> ice::Expected< T >
auto	create_thread (ice::Allocator &alloc, ice::TaskQueue &queue, ice::TaskThreadInfo const &thread_info) noexcept -> ice::UniquePtr< ice::TaskThread >
auto	create_thread_pool (ice::Allocator &alloc, ice::TaskQueue &queue, ice::TaskThreadPoolCreateInfo const &threadpool_info) noexcept -> ice::UniquePtr< ice::TaskThreadPool >
auto	await_on (ice::Task<> task, ice::TaskScheduler &resumer) noexcept -> ice::Task<>
auto	await_on (ice::Span< ice::Task<> > tasks, ice::TaskScheduler &resumer) noexcept -> ice::Task<>
auto	await_scheduled (ice::Task<> task, ice::TaskScheduler &scheduler) noexcept -> ice::Task<>
auto	await_scheduled (ice::Span< ice::Task<> > tasks, ice::TaskScheduler &scheduler) noexcept -> ice::Task<>
auto	await_scheduled_queue (ice::TaskQueue &queue, ice::TaskScheduler &scheduler) noexcept -> ice::Task< bool >
auto	await_scheduled_queue (ice::TaskQueue &queue, void *result_ptr, ice::TaskScheduler &scheduler) noexcept -> ice::Task< bool >
auto	await_scheduled_on (ice::Task<> task, ice::TaskScheduler &scheduler, ice::TaskScheduler &resumer) noexcept -> ice::Task<>
auto	await_scheduled_on (ice::Span< ice::Task<> > tasks, ice::TaskScheduler &scheduler, ice::TaskScheduler &resumer) noexcept -> ice::Task<>
auto	await_scheduled_queue_on (ice::TaskQueue &queue, ice::TaskScheduler &scheduler, ice::TaskScheduler &resumer) noexcept -> ice::Task<>
auto	await_scheduled_queue_on (ice::TaskQueue &queue, void *result_ptr, ice::TaskScheduler &scheduler, ice::TaskScheduler &resumer) noexcept -> ice::Task<>
bool	execute_task (ice::Task<> task) noexcept
bool	execute_tasks (ice::Span< ice::Task<> > tasks) noexcept
bool	schedule_task (ice::Task<> task, ice::TaskScheduler &scheduler) noexcept
bool	schedule_tasks (ice::Span< ice::Task<> > tasks, ice::TaskScheduler &scheduler) noexcept
bool	schedule_queue (ice::TaskQueue &queue, ice::TaskScheduler &scheduler) noexcept
bool	schedule_queue (ice::TaskQueue &queue, void *result_ptr, ice::TaskScheduler &scheduler) noexcept
void	wait_for (ice::Task<> task) noexcept
void	wait_for (ice::Span< ice::Task<> > tasks) noexcept
void	wait_for_scheduled (ice::Task<> task, ice::TaskScheduler &scheduler) noexcept
void	wait_for_scheduled (ice::Span< ice::Task<> > tasks, ice::TaskScheduler &scheduler) noexcept
void	manual_wait_for (ice::ManualResetEvent &evnt, ice::Task<> task) noexcept
void	manual_wait_for (ice::ManualResetBarrier &evnt, ice::Task<> task) noexcept
void	manual_wait_for (ice::ManualResetBarrier &evnt, ice::Span< ice::Task<> > tasks) noexcept
void	manual_wait_for_scheduled (ice::ManualResetEvent &evnt, ice::Task<> task, ice::TaskScheduler &scheduler) noexcept
void	manual_wait_for_scheduled (ice::ManualResetBarrier &evnt, ice::Task<> task, ice::TaskScheduler &scheduler) noexcept
void	manual_wait_for_scheduled (ice::ManualResetBarrier &evnt, ice::Span< ice::Task<> > tasks, ice::TaskScheduler &scheduler) noexcept
auto	await_filtered_queue_on (ice::TaskQueue &queue, ice::TaskScheduler &resumer, FnTaskQueueFilter filter, void *userdata=nullptr) noexcept -> ice::Task< bool >
template<typename T, typename U = T>
constexpr auto	accumulate (ice::Span< T const > range, U val) noexcept
auto	create_params (ice::Allocator &alloc, ice::String name, ice::String version, ice::String description) noexcept -> ice::Params
auto	params_process (ice::Params &params, int argc, char const *const *argv) noexcept -> ice::i32
template<typename T>
bool	params_define (ice::Params &params, ice::ParamDefinition const &definition, T &out_value) noexcept=delete
template<>
bool	params_define (ice::Params &params, ice::ParamDefinition const &definition, bool &out_value) noexcept
template<>
bool	params_define (ice::Params &params, ice::ParamDefinition const &definition, char &out_value) noexcept
template<>
bool	params_define (ice::Params &params, ice::ParamDefinition const &definition, ice::f32 &out_value) noexcept
template<>
bool	params_define (ice::Params &params, ice::ParamDefinition const &definition, ice::f64 &out_value) noexcept
template<>
bool	params_define (ice::Params &params, ice::ParamDefinition const &definition, ice::u8 &out_value) noexcept
template<>
bool	params_define (ice::Params &params, ice::ParamDefinition const &definition, ice::u16 &out_value) noexcept
template<>
bool	params_define (ice::Params &params, ice::ParamDefinition const &definition, ice::u32 &out_value) noexcept
template<>
bool	params_define (ice::Params &params, ice::ParamDefinition const &definition, ice::u64 &out_value) noexcept
template<>
bool	params_define (ice::Params &params, ice::ParamDefinition const &definition, ice::i8 &out_value) noexcept
template<>
bool	params_define (ice::Params &params, ice::ParamDefinition const &definition, ice::i16 &out_value) noexcept
template<>
bool	params_define (ice::Params &params, ice::ParamDefinition const &definition, ice::i32 &out_value) noexcept
template<>
bool	params_define (ice::Params &params, ice::ParamDefinition const &definition, ice::i64 &out_value) noexcept
template<>
bool	params_define (ice::Params &params, ice::ParamDefinition const &definition, ice::String &out_value) noexcept
template<>
bool	params_define (ice::Params &params, ice::ParamDefinition const &definition, ice::HeapString<> &out_value) noexcept
template<>
bool	params_define (ice::Params &params, ice::ParamDefinition const &definition, ice::Path &out_value) noexcept
template<>
bool	params_define (ice::Params &params, ice::ParamDefinition const &definition, ice::HeapPath &out_value) noexcept
template<>
bool	params_define (ice::Params &params, ice::ParamDefinition const &definition, ice::Array< ice::String > &out_values) noexcept
template<>
bool	params_define (ice::Params &params, ice::ParamDefinition const &definition, ice::Array< ice::HeapString<> > &out_values) noexcept
bool	params_define_custom (ice::Params &params, ice::ParamDefinition const &definition, void *userdata, ice::ParamsCustomCallback callback) noexcept
void	params_register_globals (ice::Params &params) noexcept
template<typename CharT>
auto	hash (ice::BasicPath< CharT > path) noexcept
template<typename CharT>
auto	hash (ice::BasicHeapPath< CharT > path) noexcept
auto	compare (ice::String left, ice::String right, ice::CaseSensitive=CaseSensitive::No) noexcept -> ice::CompareResult
auto	compare (ice::String left, ice::String right, ice::u64 count, ice::CaseSensitive=CaseSensitive::No) noexcept -> ice::CompareResult
auto	utf8_to_wide_size (ice::String path) noexcept -> ice::u32
bool	utf8_to_wide_append (ice::String path, ice::HeapString< ice::wchar > &out_str) noexcept
auto	utf8_to_wide (ice::Allocator &alloc, ice::String path) noexcept -> ice::HeapString< ice::wchar >
auto	wide_to_utf8_size (ice::WString path) noexcept -> ice::u32
bool	wide_to_utf8_append (ice::WString path, ice::HeapString<> &out_str) noexcept
auto	wide_to_utf8 (ice::Allocator &alloc, ice::WString path) noexcept -> ice::HeapString<>
template<typename T> requires (std::is_integral_v<T> || std::is_floating_point_v<T>)
auto	from_chars (ice::String str, T &out_value) noexcept -> ice::FromCharsResult< ice::String >
template<typename T> requires (std::is_integral_v<T> || std::is_floating_point_v<T>)
auto	from_chars (char const *str_beg, char const *str_end, T &out_value) noexcept -> ice::FromCharsResult< char const * >
template<typename T> requires (std::is_integral_v<T> || std::is_floating_point_v<T>)
auto	from_chars (ice::String str, ice::String &out_str, T &out_value) noexcept -> ice::ErrorCode
auto	from_chars (ice::String str, bool &out_value) noexcept -> ice::FromCharsResult< ice::String >
auto	from_chars (ice::String str, ice::String &out_str, bool &out_value) noexcept -> ice::ErrorCode

Variables
template<typename Type>
static constexpr ice::ContainerLogic	Constant_DefaultContainerLogic
	A helper used to pick the desired logic when it comes to handling data in collections.
static constexpr ice::ncount	ncount_max { ice::detail::nvalue_max_value() }
static constexpr ice::ncount	ncount_min { ice::detail::nvalue_min_value() }
static constexpr ice::ncount_invalid_t	ncount_none { }
static constexpr ice::meminfo	Test_Meminfo = ice::meminfo_of<ice::ncount>
static constexpr ice::nindex	nindex_max { ice::detail::nvalue_max_value() }
static constexpr ice::nindex	nindex_min { ice::detail::nvalue_min_value() }
static constexpr ice::nindex_invalid_t	nindex_none { }
template<typename T, typename = void>
constexpr bool	is_type_complete = false
template<typename T>
constexpr bool	is_type_complete< T, std::void_t< decltype(sizeof(T))> > = true
template<typename Member>
constexpr bool	is_method_member_v = member_info<Member>::member_type == 1
template<typename Member>
constexpr bool	is_field_member_v = member_info<Member>::member_type == 2
static constexpr ice::detail::TTLowestPrecisionType< Tms, Tus >	t0 { 1 }
static constexpr Tns	t1 = t0
constexpr ice::f32 const	f32_min = std::numeric_limits<ice::f32>::min()
constexpr ice::f64 const	f64_min = std::numeric_limits<ice::f64>::min()
constexpr ice::i8 const	i8_min = std::numeric_limits<ice::i8>::min()
constexpr ice::i16 const	i16_min = std::numeric_limits<ice::i16>::min()
constexpr ice::i32 const	i32_min = std::numeric_limits<ice::i32>::min()
constexpr ice::i64 const	i64_min = std::numeric_limits<ice::i64>::min()
constexpr ice::u8 const	u8_min = std::numeric_limits<ice::u8>::min()
constexpr ice::u16 const	u16_min = std::numeric_limits<ice::u16>::min()
constexpr ice::u32 const	u32_min = std::numeric_limits<ice::u32>::min()
constexpr ice::u64 const	u64_min = std::numeric_limits<ice::u64>::min()
constexpr ice::f32 const	f32_max = std::numeric_limits<ice::f32>::max()
constexpr ice::f64 const	f64_max = std::numeric_limits<ice::f64>::max()
constexpr ice::i8 const	i8_max = std::numeric_limits<ice::i8>::max()
constexpr ice::i16 const	i16_max = std::numeric_limits<ice::i16>::max()
constexpr ice::i32 const	i32_max = std::numeric_limits<ice::i32>::max()
constexpr ice::i64 const	i64_max = std::numeric_limits<ice::i64>::max()
constexpr ice::u8 const	u8_max = std::numeric_limits<ice::u8>::max()
constexpr ice::u16 const	u16_max = std::numeric_limits<ice::u16>::max()
constexpr ice::u32 const	u32_max = std::numeric_limits<ice::u32>::max()
constexpr ice::u64 const	u64_max = std::numeric_limits<ice::u64>::max()
constexpr ice::f32 const	f32_inf = std::numeric_limits<ice::f32>::infinity()
constexpr ice::f64 const	f64_inf = std::numeric_limits<ice::f64>::infinity()
constexpr ice::f32 const	f32_nan = std::numeric_limits<ice::f32>::signaling_NaN()
constexpr ice::f64 const	f64_nan = std::numeric_limits<ice::f64>::signaling_NaN()
constexpr ice::f32 const	f32_0 = ice::f32(0.0f)
constexpr ice::f64 const	f64_0 = ice::f64(0.0)
constexpr ice::i8 const	i8_0 = ice::i8(0)
constexpr ice::i16 const	i16_0 = ice::i16(0)
constexpr ice::i32 const	i32_0 = ice::i32(0)
constexpr ice::i64 const	i64_0 = ice::i64(0)
constexpr ice::u8 const	u8_0 = ice::u8(0)
constexpr ice::u16 const	u16_0 = ice::u16(0)
constexpr ice::u32 const	u32_0 = ice::u32(0)
constexpr ice::u64 const	u64_0 = ice::u64(0)
static constexpr ice::ErrorCodeSuccess	S_Ok { "S.0000:General:Success" }
static constexpr ice::ErrorCodeSuccess	S_Success = S_Ok
static constexpr ice::ErrorCodeError	E_Fail { "E.0001:General:Unknown error" }
static constexpr ice::ErrorCodeError	E_Error = E_Fail
static constexpr ice::ErrorCode	E_InvalidArgument { "E.0002:General:Invalid argument provided" }
static constexpr ice::ErrorCode	E_OutOfRange { "E.0003:General:Accessing value out of range" }
static constexpr ice::ErrorCode	E_NotImplemented { "E.0004:General:Function or method is not implemented" }
static constexpr ice::ErrorCode	E_NullPointer { "E.0005:General:Passed '{nullptr}' to function expecting valid pointer." }
static constexpr ice::ErrorCode	E_NullPointerData { "E.0006:General:Passed 'Data{nullptr}' object to function expecting valid data." }
static constexpr ice::ErrorCode	E_NullPointerMemory { "E.0007:General:Passed 'Memory{nullptr}' object to function expecting valid memory." }
static constexpr ice::ErrorCode	E_TaskCanceled { "E.1001:Tasks:Task canceled" }
static constexpr ice::Shard	Shard_Invalid { .id = { }, .payload = { } }
static constexpr ice::ShardPayloadID	ShardPayloadID_NotSet = { 0 }
template<typename T>
static constexpr ice::ShardPayloadID	Constant_ShardPayloadID = ice::ShardPayloadID_NotSet
template<>
constexpr ice::ShardPayloadID	Constant_ShardPayloadID< bool > = ice::shard_payloadid("bool")
template<>
constexpr ice::ShardPayloadID	Constant_ShardPayloadID< ice::i32 > = ice::shard_payloadid("ice::i32")
template<>
constexpr ice::ShardPayloadID	Constant_ShardPayloadID< ice::u32 > = ice::shard_payloadid("ice::u32")
template<>
constexpr ice::ShardPayloadID	Constant_ShardPayloadID< ice::f32 > = ice::shard_payloadid("ice::f32")
template<>
constexpr ice::ShardPayloadID	Constant_ShardPayloadID< ice::i64 > = ice::shard_payloadid("ice::i64")
template<>
constexpr ice::ShardPayloadID	Constant_ShardPayloadID< ice::u64 > = ice::shard_payloadid("ice::u64")
template<>
constexpr ice::ShardPayloadID	Constant_ShardPayloadID< ice::f64 > = ice::shard_payloadid("ice::f64")
template<>
constexpr ice::ShardPayloadID	Constant_ShardPayloadID< char const * > = ice::shard_payloadid("char const*")
template<>
constexpr ice::ShardPayloadID	Constant_ShardPayloadID< std::string_view const * > = ice::shard_payloadid("std::string_view const*")
template<>
constexpr ice::ShardPayloadID	Constant_ShardPayloadID< ice::StringID_Hash > = ice::shard_payloadid("ice::StringID_Hash")
static constexpr ice::StringID	StringID_Invalid { .value = StringID_Hash{ } }
static constexpr LogSeverity	lowest_compiled_log_severity
template<>
constexpr ShardPayloadID	Constant_ShardPayloadID< ice::vec2u > = ice::shard_payloadid("ice::vec2u")
template<>
constexpr ShardPayloadID	Constant_ShardPayloadID< ice::vec2i > = ice::shard_payloadid("ice::vec2i")
template<>
constexpr ShardPayloadID	Constant_ShardPayloadID< ice::vec2f > = ice::shard_payloadid("ice::vec2f")
static NullAllocator	Global_NullAllocator {}
template<typename T>
constexpr ice::usize	size_of = { sizeof(T) }
template<typename T>
constexpr ice::ualign	align_of = static_cast<ice::ualign>(alignof(T))
template<typename T>
constexpr ice::meminfo	meminfo_of = { ice::size_of<T>, ice::align_of<T> }
template<typename Enum>
static constexpr bool	Constant_IsTaskFlagsEnumeration = false
	Enables an enum type to be accepted as a task enumeration.
static constexpr TaskFlagBaseType	Constant_TaskFlagLongValue = 0x1
	Enumeration values used in the engine explicitly.
static constexpr TaskFlagBaseType	Constant_TaskFlagLowPrioValue = 0x2
static constexpr TaskFlagBaseType	Constant_TaskFlagNormalPrioValue = 0x4
static constexpr TaskFlagBaseType	Constant_TaskFlagHighPrioValue = 0x8
static constexpr ice::ErrorCode	E_ConfigIsInvalid { "E.2210:Config:Config is invalid." }
static constexpr ice::ErrorCode	E_ConfigKeyNotFound { "E.2211:Config:Config key was not found." }
static constexpr ice::ErrorCode	E_ConfigIndexOutOfBounds { "E.2211:Config:Config index was out-of-bounds." }
static constexpr ice::ErrorCode	E_ConfigValueInvalid { "E.2215:Config:Config value is not valid." }
static constexpr ice::ErrorCode	E_ConfigValueNotAnTable { "E.2216:Config:Config value is not a table." }
static constexpr ice::ErrorCode	E_ConfigValueNotAnObject { "E.2217:Config:Config value is not an object." }
static constexpr ice::ErrorCode	E_ConfigValueTypeMissmatch { "E.2218:Config:Config value type does not match the requested type." }
template<>
constexpr ice::ShardPayloadID	Constant_ShardPayloadID< ice::String const * > = ice::shard_payloadid("ice::String const*")
template<>
constexpr ice::ShardPayloadID	Constant_ShardPayloadID< ice::Tns > = ice::shard_payloadid("ice::Tns")

Detailed Description

SPDX-License-Identifier: MIT.

Copyright 2026 - 2026, Dandielo dandi.nosp@m.elo@.nosp@m.icesh.nosp@m.ard..nosp@m.net SPDX-License-Identifier: MIT

Copyright 2022 - 2026, Dandielo dandi.nosp@m.elo@.nosp@m.icesh.nosp@m.ard..nosp@m.net SPDX-License-Identifier: MIT

Copyright 2025 - 2026, Dandielo dandi.nosp@m.elo@.nosp@m.icesh.nosp@m.ard..nosp@m.net SPDX-License-Identifier: MIT

Copyright 2022 - 2025, Dandielo dandi.nosp@m.elo@.nosp@m.icesh.nosp@m.ard..nosp@m.net SPDX-License-Identifier: MIT

Copyright 2024 - 2025, Dandielo dandi.nosp@m.elo@.nosp@m.icesh.nosp@m.ard..nosp@m.net SPDX-License-Identifier: MIT

Copyright 2024 - 2026, Dandielo dandi.nosp@m.elo@.nosp@m.icesh.nosp@m.ard..nosp@m.net SPDX-License-Identifier: MIT

Copyright 2025 - 2025, Dandielo dandi.nosp@m.elo@.nosp@m.icesh.nosp@m.ard..nosp@m.net SPDX-License-Identifier: MIT

Copyright 2025 - 2026, Dandielo dandi.nosp@m.elo@.nosp@m.icesh.nosp@m.ard..nosp@m.net

Copyright 2023 - 2025, Dandielo dandi.nosp@m.elo@.nosp@m.icesh.nosp@m.ard..nosp@m.net SPDX-License-Identifier: MIT

Copyright 2023 - 2026, Dandielo dandi.nosp@m.elo@.nosp@m.icesh.nosp@m.ard..nosp@m.net SPDX-License-Identifier: MIT

Typedef Documentation

Allocator

using ice::Allocator = ice::AllocatorBase<ice::build::is_debug || ice::build::is_develop>

clean_type

template<typename T>

using ice::clean_type = clear_type_t<T>

clear_type_t

template<typename T>

using ice::clear_type_t = std::remove_pointer_t<std::remove_reference_t<std::remove_cv_t<T>>>

Color

using ice::Color = ice::color::OkLCH

const_correct_t

template<typename OwnerT, typename ValueT>

using ice::const_correct_t = typename ice::const_correct<OwnerT, ValueT>::type

coroutine_handle

template<typename Type = void>

using ice::coroutine_handle = std::coroutine_handle<Type>

f32

using ice::f32 = float

f64

using ice::f64 = double

FnCustomResumerFunc

using ice::FnCustomResumerFunc = bool(*)(void* userdata, ice::TaskAwaitableBase const& awaitable) noexcept

FnDevUIAlloc

using ice::FnDevUIAlloc = void*(*)(size_t size, void* userdata) noexcept

FnDevUIContextSetupCallback

using ice::FnDevUIContextSetupCallback

Initial value:

bool(*)(
       ice::StringID_Arg context_name,
       ice::DevUIContextSetupParams const& params,
       void* userdata
   ) noexcept

FnDevUIDealloc

using ice::FnDevUIDealloc = void(*)(void* size, void* userdata) noexcept

FnModuleLoad

using ice::FnModuleLoad = void (ice::Allocator*, ice::ModuleNegotiatorAPIContext*, ice::ModuleNegotiatorAPI*)

FnModuleSelectAPI

using ice::FnModuleSelectAPI = bool (ice::StringID_Hash, ice::u32, ice::ModuleAPI*)

FnModuleUnload

using ice::FnModuleUnload = void (ice::Allocator*)

FnTaskQueueFilter

using ice::FnTaskQueueFilter = bool(*)(ice::TaskAwaitableParams params, void* userdata) noexcept

HeapPath

using ice::HeapPath = ice::BasicHeapPath<char>

i16

using ice::i16 = std::int16_t

i32

using ice::i32 = std::int32_t

i64

using ice::i64 = std::int64_t

i8

using ice::i8 = std::int8_t

LogSinkFn

using ice::LogSinkFn = void(*)(void* userdata, ice::LogSinkMessage const& message) noexcept

make_unique_tuple

template<typename T>

using ice::make_unique_tuple = typename make_unique_tuple_helper<T>::type

member_arg_type_t

template<typename Member, ice::u64 Idx>

using ice::member_arg_type_t = std::tuple_element_t<Idx, typename member_info<Member>::argument_types>

member_class_type_t

template<typename Member>

using ice::member_class_type_t = typename member_info<Member>::class_type

member_result_type_t

template<typename Member>

using ice::member_result_type_t = typename member_info<Member>::result_type

Params

using ice::Params = ice::UniquePtr<ParamsInternal> const

ParamsCustomCallback

using ice::ParamsCustomCallback = bool(*)(void* userdata, ice::Span<ice::String const> results) noexcept

Path

using ice::Path = ice::BasicPath<char>

ProcAPIQuickRegisterFunc

template<typename T>

using ice::ProcAPIQuickRegisterFunc = void(*)(T& out_api) noexcept

RefCounted

using ice::RefCounted = ice::detail::RefCounted

Result

using ice::Result = ice::Expected<ice::ErrorCode>

ShaderColor

using ice::ShaderColor = ice::color::LRGB

StackAllocator_1024

using ice::StackAllocator_1024 = StackAllocator<1024_B>

StackAllocator_2048

using ice::StackAllocator_2048 = StackAllocator<2048_B>

StaticArray

template<typename T, ice::u32 Size>

using ice::StaticArray = std::array<T, Size>

String

using ice::String = ice::BasicString<char>

StringID

using ice::StringID

Initial value:

BaseStringID<
       ice::build::Constant_StringID_DebugInfoEnabled
   >

\copy ice::BaseStringID.

StringID_Arg

using ice::StringID_Arg

Initial value:

std::conditional_t<
       ice::build::Constant_StringID_DebugInfoEnabled,
       StringID const&,
       StringID
   >

Argument type used to pass ice::StringID values to functions.

Note

This allows the engine to control how ice::StringID values are passed in the engine. When ice::build::Constant_StringID_DebugInfoEnabled is false values are passed by values.

StrongNumericBase

template<typename T>

using ice::StrongNumericBase = typename ice::detail::ExtractMemberType<decltype(&T::value)>::Type

suspend_always

using ice::suspend_always = std::suspend_always

suspend_never

using ice::suspend_never = std::suspend_never

TaskFlagBaseType

using ice::TaskFlagBaseType = ice::u32

Base type required for an Enum to be a valid TaskFlag enumeration.

TaskThreadProcedure

using ice::TaskThreadProcedure = auto(void* userdata, ice::TaskQueue&) noexcept -> ice::u32

tuples_merged_t

template<typename... Tuples>

using ice::tuples_merged_t = typename ice::tuples_merged<Tuples...>::type

u16

using ice::u16 = std::uint16_t

u32

using ice::u32 = std::uint32_t

u64

using ice::u64 = std::uint64_t

u8

using ice::u8 = std::uint8_t

unique_tuple_t

template<typename... Ts>

using ice::unique_tuple_t = typename ice::unique_tuple<std::tuple<>, Ts...>::type

UniquePtrCustomDeleter

template<typename T>

using ice::UniquePtrCustomDeleter = void(T*) noexcept

uptr

using ice::uptr = std::uintptr_t

utf16

using ice::utf16 = char16_t

utf32

using ice::utf32 = char32_t

utf8

using ice::utf8 = char8_t

VarString

using ice::VarString = VarStringBase<char>

VarStringTag

using ice::VarStringTag = struct _tagVarString

wchar

using ice::wchar = wchar_t

WString

using ice::WString = ice::BasicString<wchar_t>

Enumeration Type Documentation

CaseSensitive

enum class ice::CaseSensitive : bool

strong

Enumerator
No
Yes

ColorFormat

enum class ice::ColorFormat : ice::u8

strong

Enumerator
OkLCH
OkLAB
LinearRGB
StandardRGB
OkLCHu8
LinearRGBu8

ColorSpace

enum class ice::ColorSpace : ice::u8

strong

Enumerator
SRGB

CompareResult

enum class ice::CompareResult : ice::i8

strong

Enumerator
Smaller
Equal
Larger

ConfigValueFlags

enum class ice::ConfigValueFlags : ice::u8

strong

Enumerator
None
AllowImplicitCasts

ConfigValueType

enum class ice::ConfigValueType : ice::u8

strong

Enumerator
Invalid
Bool
U8
U16
U32
U64
S8
S16
S32
S64
F32
F64
String
Blob
Table
Object

ContainerLogic

enum class ice::ContainerLogic : ice::u8

strong

The logic implemented by a collectiont type when working with data. (Copying, Moving, Removing, etc.).

Note

The picked logic will affect performance, but may also impose restrictions.

Enumerator
Trivial	The collection only handles plain old data and is allowed to memcopy values. Precondition The type stored in the collection satisfies std::is_pod
Complex	The collection handles complex data types and properly implements copy and move semantics.

LogSeverity

enum class ice::LogSeverity : ice::u32

strong

Enumerator
Critical
Retail
Error
Warning
Info
Verbose
Debug
None
All

LogSinkID

enum class ice::LogSinkID : uint8_t

strong

Enumerator
Invalid

LogTag

enum class ice::LogTag : ice::u64

strong

Enumerator
None
Core
System
Module
Engine
Asset
Game
Tool

ParamFlags

enum class ice::ParamFlags : ice::u32

strong

Additional flags altering command line parameter behaviors.

Enumerator
None
IsRequired
AllowExtraArgs
NoExtraArgs
TakeFirst
TakeLast
TakeAll
ValidateFile
ValidateDirectory
ValidatePath
All

TaskAwaitableModifier

enum class ice::TaskAwaitableModifier : ice::u32

strong

Enumerator
Unused
PriorityFlags
DelayedExecution
CustomValue
CustomResumer

TaskState

enum class ice::TaskState : ice::u8

strong

All states a task can be in.

Enumerator
None	Special state from TaskHandles, handle is not initialized.
Invalid	Special state from TaskHandles, handle is not initialized.
Created	Task exists, but execution did not start.
Running	Task, or one of it's subtasks are executing.
Suspended	Task is suspended and awaits resuming. (Unused).
Succeeded	Task finished execution with a valid result.
Canceled	Task was canceled at any point of it's lifetime.
Failed	Task finished execution but results are invalid.
All

ualign

enum class ice::ualign : ice::u32

strong

Enumerator
invalid
b_1
b_2
b_4
b_8
b_16
b_32
b_64
b_128
b_256
b_512
b_1024
b_2048
b_default

Function Documentation

accumulate()

template<typename T, typename U = T>

auto ice::accumulate ( ice::Span< T const > range, U val )

constexprnoexcept

accumulate_over()

template<typename Type, typename Fn>

auto ice::accumulate_over ( ice::Span< Type > objects, Fn && fn ) -> ice::u32

inlinenoexcept

align_to()

template<typename T>
requires std::is_pointer_v<T> || std::is_same_v<T, ice::usize> || std::is_integral_v<T>

auto ice::align_to ( T value, ice::ualign alignment ) -> ice::AlignResult< T >

constexprnoexcept

alloc()

auto ice::alloc ( ice::usize size ) -> ice::AllocResult

noexcept

alloc_aligned()

auto ice::alloc_aligned ( ice::usize size, ice::ualign alignment ) -> ice::AllocResult

noexcept

await_filtered_queue_on()

auto ice::await_filtered_queue_on ( ice::TaskQueue & queue, ice::TaskScheduler & resumer, FnTaskQueueFilter filter, void * userdata = nullptr ) -> ice::Task< bool >

noexcept

await_on() [1/3]

auto ice::await_on ( ice::Span< ice::Task<> > tasks, ice::TaskScheduler & resumer ) -> ice::Task<>

noexcept

await_on() [2/3]

template<typename T>

auto ice::await_on ( ice::Task< T > task, ice::TaskScheduler & resumer ) -> ice::Task< T >

inlinenoexcept

await_on() [3/3]

auto ice::await_on ( ice::Task<> task, ice::TaskScheduler & resumer ) -> ice::Task<>

noexcept

await_scheduled() [1/3]

auto ice::await_scheduled ( ice::Span< ice::Task<> > tasks, ice::TaskScheduler & scheduler ) -> ice::Task<>

noexcept

await_scheduled() [2/3]

template<typename T>

auto ice::await_scheduled ( ice::Task< T > task, ice::TaskScheduler & scheduler ) -> ice::Task< T >

inlinenoexcept

await_scheduled() [3/3]

auto ice::await_scheduled ( ice::Task<> task, ice::TaskScheduler & scheduler ) -> ice::Task<>

noexcept

await_scheduled_on() [1/3]

auto ice::await_scheduled_on ( ice::Span< ice::Task<> > tasks, ice::TaskScheduler & scheduler, ice::TaskScheduler & resumer ) -> ice::Task<>

noexcept

await_scheduled_on() [2/3]

template<typename T>

auto ice::await_scheduled_on ( ice::Task<> task, ice::TaskScheduler & scheduler, ice::TaskScheduler & resumer ) -> ice::Task< T >

inlinenoexcept

await_scheduled_on() [3/3]

auto ice::await_scheduled_on ( ice::Task<> task, ice::TaskScheduler & scheduler, ice::TaskScheduler & resumer ) -> ice::Task<>

noexcept

await_scheduled_queue() [1/2]

auto ice::await_scheduled_queue ( ice::TaskQueue & queue, ice::TaskScheduler & scheduler ) -> ice::Task< bool >

noexcept

await_scheduled_queue() [2/2]

auto ice::await_scheduled_queue ( ice::TaskQueue & queue, void * result_ptr, ice::TaskScheduler & scheduler ) -> ice::Task< bool >

noexcept

await_scheduled_queue_on() [1/2]

auto ice::await_scheduled_queue_on ( ice::TaskQueue & queue, ice::TaskScheduler & scheduler, ice::TaskScheduler & resumer ) -> ice::Task<>

noexcept

await_scheduled_queue_on() [2/2]

auto ice::await_scheduled_queue_on ( ice::TaskQueue & queue, void * result_ptr, ice::TaskScheduler & scheduler, ice::TaskScheduler & resumer ) -> ice::Task<>

noexcept

await_tasks()

auto ice::await_tasks ( ice::Span< ice::Task<> > tasks ) -> ice::Task<>

inlinenoexcept

binary_search() [1/2]

template<typename T, typename Comp, typename U = T>
requires (std::convertible_to<T, U>)

bool ice::binary_search ( ice::Span< T > values, U const & value, Comp && comp, ice::u32 & out_index )

constexprnoexcept

binary_search() [2/2]

template<typename T, typename U = T>
requires (std::convertible_to<T, U>)

bool ice::binary_search ( ice::Span< T > values, U const & value, ice::u32 & out_index )

constexprnoexcept

compare() [1/2]

auto ice::compare ( ice::String left, ice::String right, ice::CaseSensitive = CaseSensitive::No ) -> ice::CompareResult

noexcept

compare() [2/2]

auto ice::compare ( ice::String left, ice::String right, ice::u64 count, ice::CaseSensitive = CaseSensitive::No ) -> ice::CompareResult

noexcept

constexpr_sort_stdarray()

template<typename T>

auto ice::constexpr_sort_stdarray ( T const & arr, ice::u32 start_offset = 0 ) -> T

constexprnoexcept

count()

template<typename T, ice::u32 Size>

auto ice::count ( T const(&)[Size] ) -> ice::u32

constexprnoexcept

create_default_module_register()

auto ice::create_default_module_register ( ice::Allocator & alloc, bool load_global_modules = true ) -> ice::UniquePtr< ice::ModuleRegister >

noexcept

Creates a default module register.

Parameters

[in]	alloc	The allocator to use for the module register.
[in]	load_global_modules	If true, all modules available in the current executable will be loaded.

create_devui_context()

auto ice::create_devui_context ( ice::Allocator & alloc, ice::ModuleQuery & query ) -> ice::UniquePtr< ice::DevUIContext >

noexcept

create_log_tag() [1/2]

auto ice::create_log_tag ( LogTag base_tag, ice::String name ) -> LogTagDefinition

constexprnoexcept

create_log_tag() [2/2]

auto ice::create_log_tag ( LogTagDefinition const & base_tag_def, ice::String name ) -> LogTagDefinition

constexprnoexcept

create_params()

auto ice::create_params ( ice::Allocator & alloc, ice::String name, ice::String version, ice::String description ) -> ice::Params

nodiscardnoexcept

create_thread()

auto ice::create_thread ( ice::Allocator & alloc, ice::TaskQueue & queue, ice::TaskThreadInfo const & thread_info ) -> ice::UniquePtr< ice::TaskThread >

noexcept

create_thread_pool()

auto ice::create_thread_pool ( ice::Allocator & alloc, ice::TaskQueue & queue, ice::TaskThreadPoolCreateInfo const & threadpool_info ) -> ice::UniquePtr< ice::TaskThreadPool >

noexcept

data_copy()

auto ice::data_copy ( ice::Allocator & alloc, ice::Data data ) -> ice::Memory

inlinenoexcept

data_view() [1/4]

template<typename Type, ice::ContainerLogic Logic>

auto ice::data_view ( ice::Array< Type, Logic > const & arr ) -> ice::Data=delete

deletenoexcept

data_view() [2/4]

auto ice::data_view ( ice::Memory memory ) -> ice::Data

constexprnoexcept

data_view() [3/4]

template<typename Type>

auto ice::data_view ( Type const & var )

inlinenoexcept

data_view() [4/4]

template<typename Type, ice::usize::base_type Size>

auto ice::data_view ( Type const(&) var[Size] )

constexprnoexcept

devui_available()

bool ice::devui_available ( )

noexcept

devui_context_setup_default()

bool ice::devui_context_setup_default ( ice::StringID_Arg context_name, ice::DevUIContextSetupParams const & params, void * userdata )

noexcept

devui_register_widget()

bool ice::devui_register_widget ( ice::DevUIWidget * widget, ice::DevUIWidget * owning_widget = nullptr )

noexcept

devui_remove_widget()

bool ice::devui_remove_widget ( ice::DevUIWidget * widget )

noexcept

devui_setup_context()

bool ice::devui_setup_context ( ice::ModuleQuery const & query, ice::FnDevUIContextSetupCallback callback = ice::devui_context_setup_default, void * userdata = nullptr )

noexcept

devui_setup_mainmenu()

void ice::devui_setup_mainmenu ( ice::Span< ice::String > categories )

noexcept

devui_trait_name()

auto ice::devui_trait_name ( ) -> ice::StringID

noexcept

equal()

template<typename Left, typename Right = Left>

auto ice::equal ( Left && left, Right && right ) -> bool

constexprnoexcept

execute_task()

bool ice::execute_task ( ice::Task<> task )

noexcept

execute_tasks()

bool ice::execute_tasks ( ice::Span< ice::Task<> > tasks )

noexcept

from_chars() [1/5]

template<typename T>
requires (std::is_integral_v<T> || std::is_floating_point_v<T>)

auto ice::from_chars ( char const * str_beg, char const * str_end, T & out_value ) -> ice::FromCharsResult< char const * >

noexcept

from_chars() [2/5]

auto ice::from_chars ( ice::String str, bool & out_value ) -> ice::FromCharsResult< ice::String >

inlinenoexcept

from_chars() [3/5]

auto ice::from_chars ( ice::String str, ice::String & out_str, bool & out_value ) -> ice::ErrorCode

inlinenoexcept

from_chars() [4/5]

template<typename T>
requires (std::is_integral_v<T> || std::is_floating_point_v<T>)

auto ice::from_chars ( ice::String str, ice::String & out_str, T & out_value ) -> ice::ErrorCode

noexcept

from_chars() [5/5]

template<typename T>
requires (std::is_integral_v<T> || std::is_floating_point_v<T>)

auto ice::from_chars ( ice::String str, T & out_value ) -> ice::FromCharsResult< ice::String >

noexcept

has_all()

template<ice::FlagType T>

bool ice::has_all ( T value, T expected_flags )

constexprnoexcept

has_any()

template<ice::FlagType T>

bool ice::has_any ( T value, T expected_flags )

constexprnoexcept

has_none()

template<ice::FlagType T>

bool ice::has_none ( T value, T expected_flags )

constexprnoexcept

hash() [1/16]

template<>

auto ice::hash ( char const * value ) -> ice::u64

constexprnoexcept

hash() [2/16]

template<>

auto ice::hash ( char const * value ) -> ice::u64

constexprnoexcept

hash() [3/16]

template<typename CharT>

auto ice::hash ( ice::BasicHeapPath< CharT > path )

noexcept

hash() [4/16]

template<typename CharT>

auto ice::hash ( ice::BasicPath< CharT > path )

noexcept

hash() [5/16]

auto ice::hash ( ice::HeapString<> const & value ) -> ice::u64

constexprnoexcept

hash() [6/16]

template<>

auto ice::hash ( ice::ShardID shardid ) -> ice::u64

constexprnoexcept

hash() [7/16]

auto ice::hash ( ice::String value ) -> ice::u64

constexprnoexcept

hash() [8/16]

auto ice::hash ( ice::StringID_Arg value ) -> ice::u64

constexprnoexcept

hash() [9/16]

auto ice::hash ( ice::StringID_Hash sid_hash ) -> ice::u64

constexprnoexcept

hash() [10/16]

template<>

auto ice::hash ( ice::utf8 const * value ) -> ice::u64

constexprnoexcept

hash() [11/16]

template<>

auto ice::hash ( ice::utf8 const * value ) -> ice::u64

constexprnoexcept

hash() [12/16]

template<>

auto ice::hash ( std::string_view value ) -> ice::u64

constexprnoexcept

hash() [13/16]

template<>

auto ice::hash ( std::string_view value ) -> ice::u64

constexprnoexcept

hash() [14/16]

template<>

auto ice::hash ( std::u8string_view value ) -> ice::u64

constexprnoexcept

hash() [15/16]

template<>

auto ice::hash ( std::u8string_view value ) -> ice::u64

constexprnoexcept

hash() [16/16]

template<typename T>

auto ice::hash ( T value ) -> ice::u64

constexprnoexcept

hash32() [1/11]

template<>

auto ice::hash32 ( char const * value ) -> ice::u32

constexprnoexcept

hash32() [2/11]

template<>

auto ice::hash32 ( char const * value ) -> ice::u32

constexprnoexcept

hash32() [3/11]

auto ice::hash32 ( ice::ShardID shardid ) -> ice::u32

constexprnoexcept

hash32() [4/11]

auto ice::hash32 ( ice::String value ) -> ice::u32

constexprnoexcept

hash32() [5/11]

template<>

auto ice::hash32 ( ice::utf8 const * value ) -> ice::u32

constexprnoexcept

hash32() [6/11]

template<>

auto ice::hash32 ( ice::utf8 const * value ) -> ice::u32

constexprnoexcept

hash32() [7/11]

template<>

auto ice::hash32 ( std::string_view value ) -> ice::u32

constexprnoexcept

hash32() [8/11]

template<>

auto ice::hash32 ( std::string_view value ) -> ice::u32

constexprnoexcept

hash32() [9/11]

template<>

auto ice::hash32 ( std::u8string_view value ) -> ice::u32

constexprnoexcept

hash32() [10/11]

template<>

auto ice::hash32 ( std::u8string_view value ) -> ice::u32

constexprnoexcept

hash32() [11/11]

template<typename T>

auto ice::hash32 ( T value ) -> uint32_t

constexprnoexcept

hash_from_ptr()

template<typename T>

auto ice::hash_from_ptr ( T * ptr ) -> ice::u64

constexprnoexcept

is_aligned() [1/2]

bool ice::is_aligned ( ice::u32 val, ice::ualign alignment )

inlinenoexcept

is_aligned() [2/2]

bool ice::is_aligned ( void const * ptr, ice::ualign alignment )

inlinenoexcept

less()

template<typename Left, typename Right = Left>

auto ice::less ( Left const & left, Right const & right ) -> bool

constexprnoexcept

load_global_modules()

auto ice::load_global_modules ( ice::Allocator & alloc, ice::ModuleRegister & modules_register ) -> ice::u32

noexcept

Loads all modules available in the current executable.

Note

This can be done automatically when creating the default module register.

As of now, loading modules twice might result in unexpected issues.

log_module_init()

void ice::log_module_init ( ice::Allocator & alloc, ice::ModuleNegotiatorBase const & negotiator )

noexcept

log_module_register_sink()

auto ice::log_module_register_sink ( LogSinkFn fn_sink, void * userdata ) -> ice::LogSinkID

noexcept

log_module_unregister_sink()

void ice::log_module_unregister_sink ( ice::LogSinkID sink_id )

noexcept

log_tag_enable()

void ice::log_tag_enable ( ice::LogTag tag, bool enabled = true )

noexcept

log_tag_register()

void ice::log_tag_register ( ice::LogTagDefinition tag_def )

noexcept

lower_bound() [1/2]

template<typename T, typename U = T>
requires (std::convertible_to<T, U>)

auto ice::lower_bound ( ice::Span< T > values, U const & value ) -> ice::u32

constexprnoexcept

lower_bound() [2/2]

template<typename T, typename Comp, typename U = T>
requires (std::convertible_to<T, U>)

auto ice::lower_bound ( ice::Span< T > values, U const & value, Comp && comp ) -> ice::u32

constexprnoexcept

make_span() [1/4]

template<typename Type, size_t Size>

auto ice::make_span ( std::array< Type, Size > & std_array ) -> Span< Type >

inlineconstexprnoexcept

make_span() [2/4]

template<typename Type, size_t Size>

constexpr auto ice::make_span ( std::array< Type, Size > & std_array ) -> Span< Type >

inlinestaticconstexprnoexcept

make_span() [3/4]

template<typename Type, size_t Size>

auto ice::make_span ( std::array< Type, Size > const & std_array ) -> Span< Type const >

inlineconstexprnoexcept

make_span() [4/4]

template<typename Type, size_t Size>

constexpr auto ice::make_span ( std::array< Type, Size > const & std_array ) -> Span< Type const >

inlinestaticconstexprnoexcept

make_unique() [1/2]

template<typename T, typename... Args>

auto ice::make_unique ( ice::Allocator & alloc, Args &&... args ) -> ice::UniquePtr< T >

inlinenoexcept

make_unique() [2/2]

template<typename T>

auto ice::make_unique ( ice::UniquePtrCustomDeleter< T > * fn_deleter, T * instanced_object ) -> ice::UniquePtr< T >

inlinenoexcept

manual_wait_for() [1/3]

void ice::manual_wait_for ( ice::ManualResetBarrier & evnt, ice::Span< ice::Task<> > tasks )

noexcept

manual_wait_for() [2/3]

void ice::manual_wait_for ( ice::ManualResetBarrier & evnt, ice::Task<> task )

noexcept

manual_wait_for() [3/3]

void ice::manual_wait_for ( ice::ManualResetEvent & evnt, ice::Task<> task )

noexcept

manual_wait_for_scheduled() [1/3]

void ice::manual_wait_for_scheduled ( ice::ManualResetBarrier & evnt, ice::Span< ice::Task<> > tasks, ice::TaskScheduler & scheduler )

noexcept

manual_wait_for_scheduled() [2/3]

void ice::manual_wait_for_scheduled ( ice::ManualResetBarrier & evnt, ice::Task<> task, ice::TaskScheduler & scheduler )

noexcept

manual_wait_for_scheduled() [3/3]

void ice::manual_wait_for_scheduled ( ice::ManualResetEvent & evnt, ice::Task<> task, ice::TaskScheduler & scheduler )

noexcept

mem_construct_at() [1/2]

template<typename T, typename... Args>

auto ice::mem_construct_at ( ice::Memory memory, Args &&... args ) -> T *

noexcept

mem_construct_at() [2/2]

template<typename T, typename... Args>

auto ice::mem_construct_at ( void * memory_ptr, Args &&... args ) -> T *

noexcept

mem_copy_construct_at()

template<typename T>

auto ice::mem_copy_construct_at ( ice::Memory memory, T const & other ) -> T *

noexcept

mem_copy_construct_it_at()

template<typename T, typename ItT>

auto ice::mem_copy_construct_it_at ( ice::Memory memory, ItT begin, ItT end ) -> T *

noexcept

mem_copy_construct_n_at()

template<typename T>

auto ice::mem_copy_construct_n_at ( ice::Memory memory, T const * objects, ice::u64 count ) -> T *

noexcept

mem_default_construct_n_at()

template<typename T>

auto ice::mem_default_construct_n_at ( ice::Memory memory, ice::u64 count ) -> T *

noexcept

mem_destruct_at()

template<typename T>

void ice::mem_destruct_at ( T * location )

noexcept

mem_destruct_n_at()

template<typename T>

void ice::mem_destruct_n_at ( T * location, ice::u64 count )

noexcept

mem_max_capacity() [1/2]

auto ice::mem_max_capacity ( ice::usize element_size, ice::usize memory_space ) -> ice::u64

constexprnoexcept

mem_max_capacity() [2/2]

template<typename T>

auto ice::mem_max_capacity ( ice::usize memory_space ) -> ice::u64

constexprnoexcept

mem_move_construct_at() [1/2]

template<typename T>

auto ice::mem_move_construct_at ( ice::Memory memory, T && other ) -> T *

noexcept

mem_move_construct_at() [2/2]

template<typename T>

auto ice::mem_move_construct_at ( void * memory_ptr, T && other ) -> T *

noexcept

mem_move_construct_n_at()

template<typename T>

auto ice::mem_move_construct_n_at ( ice::Memory memory, T * objects, ice::u64 count ) -> T *

noexcept

mem_move_n_to()

template<typename T>

auto ice::mem_move_n_to ( T * target_objects, T * objects, ice::u64 count ) -> T *

noexcept

memcpy() [1/3]

auto ice::memcpy ( ice::Memory memory, ice::Data data ) -> ice::Memory

noexcept

memcpy() [2/3]

auto ice::memcpy ( void * dest, ice::Data source ) -> void *

noexcept

memcpy() [3/3]

auto ice::memcpy ( void * dest, void const * source, ice::usize size ) -> void *

noexcept

memory_from()

template<typename T>
requires (std::is_array_v<T> == false && std::is_pointer_v<T> == false)

auto ice::memory_from ( T & object ) -> ice::Memory

constexprnoexcept

memset()

auto ice::memset ( ice::Memory memory, ice::u8 value ) -> ice::Memory

noexcept

offset_of()

template<typename Field, typename Class>

auto ice::offset_of ( Field Class::* member ) -> ice::uptr

constexprnoexcept

operator!()

template<ice::BoolType T>

auto ice::operator! ( T left ) -> T

constexprnoexcept

operator""_B()

auto ice::operator""_B ( unsigned long long v ) -> ice::usize

constexprnoexcept

operator""_count()

auto ice::operator""_count ( unsigned long long value ) -> ice::ncount

constexprnoexcept

operator""_i18n()

auto ice::operator""_i18n ( char const * text, size_t size ) -> I18NReference

constexprnoexcept

operator""_index()

auto ice::operator""_index ( unsigned long long value ) -> ice::nindex

constexprnoexcept

operator""_KiB()

auto ice::operator""_KiB ( unsigned long long v ) -> ice::usize

constexprnoexcept

operator""_MiB()

auto ice::operator""_MiB ( unsigned long long v ) -> ice::usize

constexprnoexcept

operator""_shard() [1/2]

auto ice::operator""_shard ( char const * str, size_t size ) -> ice::Shard

constexprnoexcept

operator""_shard() [2/2]

auto ice::operator""_shard ( ice::utf8 const * str, size_t size ) -> ice::Shard

constexprnoexcept

operator""_shardid() [1/2]

auto ice::operator""_shardid ( char const * str, size_t size ) -> ice::ShardID

constexprnoexcept

operator""_shardid() [2/2]

auto ice::operator""_shardid ( ice::utf8 const * str, size_t size ) -> ice::ShardID

constexprnoexcept

operator""_sid()

auto ice::operator""_sid ( char const * str, size_t len )

constexprnoexcept

operator""_sid_hash()

auto ice::operator""_sid_hash ( char const * str, size_t len )

constexprnoexcept

operator""_str()

auto ice::operator""_str ( char const * buffer, size_t size ) -> ice::BasicString< char >

constexprnoexcept

operator""_Tms()

auto ice::operator""_Tms ( unsigned long long time ) -> ice::Tms

constexprnoexcept

operator""_Tns()

auto ice::operator""_Tns ( unsigned long long time ) -> ice::Tns

constexprnoexcept

operator""_Ts() [1/2]

auto ice::operator""_Ts ( long double time ) -> ice::Ts

constexprnoexcept

operator""_Ts() [2/2]

auto ice::operator""_Ts ( unsigned long long time ) -> ice::Ts

constexprnoexcept

operator""_Tus()

auto ice::operator""_Tus ( unsigned long long time ) -> ice::Tus

constexprnoexcept

operator%() [1/2]

auto ice::operator% ( ice::isize left, ice::ualign right ) -> ice::isize

constexprnoexcept

operator%() [2/2]

auto ice::operator% ( ice::usize left, ice::ualign right ) -> ice::usize

constexprnoexcept

operator&()

template<ice::FlagType T>

auto ice::operator& ( T left, T right ) -> T

constexprnoexcept

operator&=()

template<ice::FlagType T>

auto ice::operator&= ( T & left, T right ) -> T &

constexprnoexcept

operator*() [1/3]

auto ice::operator* ( ice::meminfo info, ice::u64 count ) -> ice::meminfo

constexprnoexcept

Multypling ice::meminfo by a scalar changes the size but keeps the alignment.

operator*() [2/3]

template<typename T>
requires StrongNumericType<T>

auto ice::operator* ( T left, ice::StrongNumericBase< T > right ) -> T

constexprnoexcept

operator*() [3/3]

template<typename T>
requires StrongNumericType<T>

auto ice::operator* ( T left, T right ) -> T

constexprnoexcept

operator*=() [1/2]

template<typename T>
requires StrongNumericType<T>

auto ice::operator*= ( T & left, ice::StrongNumericBase< T > right ) -> T &

constexprnoexcept

operator*=() [2/2]

template<typename T>
requires StrongNumericType<T>

auto ice::operator*= ( T & left, T right ) -> T &

constexprnoexcept

operator+() [1/4]

auto ice::operator+ ( ice::isize left, ice::usize right ) -> ice::isize

constexprnoexcept

operator+() [2/4]

auto ice::operator+ ( ice::TimeType auto left, TimeType auto right )

constexprnoexcept

operator+() [3/4]

auto ice::operator+ ( ice::usize left, ice::isize right ) -> ice::isize

constexprnoexcept

operator+() [4/4]

template<typename T>
requires StrongNumericType<T>

auto ice::operator+ ( T left, T right ) -> T

constexprnoexcept

operator+=() [1/2]

auto ice::operator+= ( ice::meminfo & left, ice::meminfo right ) -> ice::usize

constexprnoexcept

Adding two ice::meminfo values changes the size and and alignment.

Remarks

The resulting alignment will contain the alignment of the added ice::meminfo.

The resulting size may grow more than the added ice::meminfo. This is because the operator adds the required offset (if any) to the size.

Parameters

[in,out]	left	The ice::meminfo object that is updated.
[in]	right	The description of memory we want to append to the total size.

Returns

The offset at which the described memory would be located in a single memory block.

operator+=() [2/2]

template<typename T>
requires StrongNumericType<T>

auto ice::operator+= ( T & left, T right ) -> T &

constexprnoexcept

operator-() [1/7]

auto ice::operator- ( ice::isize left, ice::usize right ) -> ice::isize

constexprnoexcept

operator-() [2/7]

auto ice::operator- ( ice::TimeType auto left, TimeType auto right )

constexprnoexcept

operator-() [3/7]

auto ice::operator- ( ice::usize left ) -> ice::isize

constexprnoexcept

operator-() [4/7]

auto ice::operator- ( ice::usize left, ice::isize right ) -> ice::isize

constexprnoexcept

operator-() [5/7]

auto ice::operator- ( ice::usize left, ice::usize right ) -> ice::isize

constexprnoexcept

operator-() [6/7]

template<typename T>
requires StrongNumericType<T>

auto ice::operator- ( T left ) -> T

constexprnoexcept

operator-() [7/7]

template<typename T>
requires StrongNumericType<T>

auto ice::operator- ( T left, T right ) -> T

constexprnoexcept

operator-=() [1/2]

auto ice::operator-= ( ice::usize & left, ice::usize right ) -> ice::usize &=delete

constexprdeletenoexcept

operator-=() [2/2]

template<typename T>
requires StrongNumericType<T>

auto ice::operator-= ( T & left, T right ) -> T &

constexprnoexcept

operator/() [1/2]

template<typename T>
requires StrongNumericType<T>

auto ice::operator/ ( T left, ice::StrongNumericBase< T > right ) -> T

constexprnoexcept

operator/() [2/2]

template<typename T>
requires StrongNumericType<T>

auto ice::operator/ ( T left, T right ) -> T

constexprnoexcept

operator/=() [1/2]

template<typename T>
requires StrongNumericType<T>

auto ice::operator/= ( T & left, ice::StrongNumericBase< T > right ) -> T &

constexprnoexcept

operator/=() [2/2]

template<typename T>
requires StrongNumericType<T>

auto ice::operator/= ( T & left, T right ) -> T &

constexprnoexcept

operator<=>() [1/5]

auto ice::operator<=> ( ice::isize left, ice::usize right )

constexprnoexcept

operator<=>() [2/5]

auto ice::operator<=> ( ice::StringID_Arg left, ice::StringID_Arg right )

constexprnoexcept

operator<=>() [3/5]

auto ice::operator<=> ( ice::TimeType auto left, TimeType auto right )

constexprnoexcept

operator<=>() [4/5]

auto ice::operator<=> ( ice::usize left, ice::isize right )

constexprnoexcept

operator<=>() [5/5]

template<typename T>
requires ice::StrongNumericType<T>

auto ice::operator<=> ( T left, T right )

constexprnoexcept

operator==() [1/15]

bool ice::operator== ( ErrorCode lhs, bool value )

inlineconstexprnoexcept

operator==() [2/15]

bool ice::operator== ( ErrorCode lhs, ErrorCode rhs )

inlineconstexprnoexcept

operator==() [3/15]

bool ice::operator== ( ErrorCode lhs, ErrorCodeError  )

inlineconstexprnoexcept

operator==() [4/15]

bool ice::operator== ( ErrorCode lhs, ErrorCodeSuccess  )

inlineconstexprnoexcept

operator==() [5/15]

bool ice::operator== ( ErrorCodeError lhs, ErrorCodeError  )

inlineconstexprnoexcept

operator==() [6/15]

bool ice::operator== ( ErrorCodeSuccess lhs, ErrorCodeError  )

inlineconstexprnoexcept

operator==() [7/15]

bool ice::operator== ( ErrorCodeSuccess lhs, ErrorCodeSuccess  )

inlineconstexprnoexcept

operator==() [8/15]

auto ice::operator== ( ice::Shard left, ice::Shard right ) -> bool

constexprnoexcept

operator==() [9/15]

auto ice::operator== ( ice::Shard left, ice::ShardID right ) -> bool

constexprnoexcept

operator==() [10/15]

auto ice::operator== ( ice::ShardID left, ice::ShardID right ) -> bool

constexprnoexcept

operator==() [11/15]

auto ice::operator== ( ice::TimeType auto left, TimeType auto right )

constexprnoexcept

operator==() [12/15]

auto ice::operator== ( ice::usize left, ice::isize right ) -> bool

constexprnoexcept

operator==() [13/15]

template<typename T>
requires ice::StrongValueType<T>

bool ice::operator== ( T left, T right )

constexprnoexcept

operator==() [14/15]

template<typename T>
requires ice::StrongNumericType<T>

auto ice::operator== ( T left, T right ) -> bool

constexprnoexcept

operator==() [15/15]

template<typename T, typename U>
requires ice::SameTaggedTypes<T, U>

bool ice::operator== ( T left, U right )

constexprnoexcept

operator|() [1/3]

template<typename T>
requires ice::HasShardPayloadID<T>

auto ice::operator| ( ice::Shard shard, T payload ) -> ice::Shard

constexprnoexcept

operator|() [2/3]

template<typename T>
requires ice::HasShardPayloadID<T>

auto ice::operator| ( ice::ShardID shardid, T payload ) -> ice::Shard

constexprnoexcept

operator|() [3/3]

template<ice::FlagType T>

auto ice::operator| ( T left, T right ) -> T

constexprnoexcept

operator|=()

template<ice::FlagType T>

auto ice::operator|= ( T & left, T right ) -> T &

constexprnoexcept

operator~()

template<ice::FlagType T>

auto ice::operator~ ( T left ) -> T

constexprnoexcept

params_define() [1/19]

template<>

bool ice::params_define ( ice::Params & params, ice::ParamDefinition const & definition, bool & out_value )

noexcept

params_define() [2/19]

template<>

bool ice::params_define ( ice::Params & params, ice::ParamDefinition const & definition, char & out_value )

noexcept

params_define() [3/19]

template<>

bool ice::params_define ( ice::Params & params, ice::ParamDefinition const & definition, ice::Array< ice::HeapString<> > & out_values )

noexcept

params_define() [4/19]

template<>

bool ice::params_define ( ice::Params & params, ice::ParamDefinition const & definition, ice::Array< ice::String > & out_values )

noexcept

params_define() [5/19]

template<>

bool ice::params_define ( ice::Params & params, ice::ParamDefinition const & definition, ice::f32 & out_value )

noexcept

params_define() [6/19]

template<>

bool ice::params_define ( ice::Params & params, ice::ParamDefinition const & definition, ice::f64 & out_value )

noexcept

params_define() [7/19]

template<>

bool ice::params_define ( ice::Params & params, ice::ParamDefinition const & definition, ice::HeapPath & out_value )

noexcept

params_define() [8/19]

template<>

bool ice::params_define ( ice::Params & params, ice::ParamDefinition const & definition, ice::HeapString<> & out_value )

noexcept

params_define() [9/19]

template<>

bool ice::params_define ( ice::Params & params, ice::ParamDefinition const & definition, ice::i16 & out_value )

noexcept

params_define() [10/19]

template<>

bool ice::params_define ( ice::Params & params, ice::ParamDefinition const & definition, ice::i32 & out_value )

noexcept

params_define() [11/19]

template<>

bool ice::params_define ( ice::Params & params, ice::ParamDefinition const & definition, ice::i64 & out_value )

noexcept

params_define() [12/19]

template<>

bool ice::params_define ( ice::Params & params, ice::ParamDefinition const & definition, ice::i8 & out_value )

noexcept

params_define() [13/19]

template<>

bool ice::params_define ( ice::Params & params, ice::ParamDefinition const & definition, ice::Path & out_value )

noexcept

params_define() [14/19]

template<>

bool ice::params_define ( ice::Params & params, ice::ParamDefinition const & definition, ice::String & out_value )

noexcept

params_define() [15/19]

template<>

bool ice::params_define ( ice::Params & params, ice::ParamDefinition const & definition, ice::u16 & out_value )

noexcept

params_define() [16/19]

template<>

bool ice::params_define ( ice::Params & params, ice::ParamDefinition const & definition, ice::u32 & out_value )

noexcept

params_define() [17/19]

template<>

bool ice::params_define ( ice::Params & params, ice::ParamDefinition const & definition, ice::u64 & out_value )

noexcept

params_define() [18/19]

template<>

bool ice::params_define ( ice::Params & params, ice::ParamDefinition const & definition, ice::u8 & out_value )

noexcept

params_define() [19/19]

template<typename T>

bool ice::params_define ( ice::Params & params, ice::ParamDefinition const & definition, T & out_value )

deletenoexcept

params_define_custom()

bool ice::params_define_custom ( ice::Params & params, ice::ParamDefinition const & definition, void * userdata, ice::ParamsCustomCallback callback )

noexcept

params_process()

auto ice::params_process ( ice::Params & params, int argc, char const *const * argv ) -> ice::i32

nodiscardnoexcept

params_register_globals()

void ice::params_register_globals ( ice::Params & params )

noexcept

ptr_add() [1/4]

auto ice::ptr_add ( ice::Data mem, ice::usize offset ) -> ice::Data

inlinenoexcept

ptr_add() [2/4]

auto ice::ptr_add ( ice::Memory mem, ice::usize offset ) -> ice::Memory

inlinenoexcept

Returns

'memory' object advanced by the number of 'offset' bytes and reduced 'size' member.

Note

The resulting 'size' member is not checked and the value may overflow.

The 'align' member remains unchanged.

ptr_add() [3/4]

auto ice::ptr_add ( void * pointer, ice::usize offset ) -> void *

inlinenoexcept

Returns

'pointer' value advanced by the number of 'offset' bytes.

ptr_add() [4/4]

auto ice::ptr_add ( void const * pointer, ice::usize offset ) -> void const *

inlinenoexcept

Returns

'pointer' value advanced by the number of 'offset' bytes.

ptr_adv() [1/4]

auto ice::ptr_adv ( ice::Memory mem, ice::meminfo meminfo ) -> ice::Memory

inlinenoexcept

Returns

'memory' object advanced by the number of 'offset' bytes, aligned to 'meminfo.alignment' with reduced 'size' member.

Note

The resulting 'size' member is not checked and the value may overflow.

The 'align' member is updated to the meminfo alignment value.

ptr_adv() [2/4]

auto ice::ptr_adv ( ice::Memory mem, ice::usize offset, ice::ualign align ) -> ice::Memory

inlinenoexcept

Returns

'memory' object advanced by the number of 'offset' bytes, aligned to 'alignment' with a reduced 'size' member.

Note

The resulting 'size' member is not checked and the value may overflow.

The 'align' member is updated to the requested alignment value.

ptr_adv() [3/4]

auto ice::ptr_adv ( void * pointer, ice::usize offset, ice::ualign align ) -> void *

inlinenoexcept

Returns

'pointer' value advanced by the number of 'offset' bytes and aligned to the given 'alignment'

ptr_adv() [4/4]

auto ice::ptr_adv ( void const * pointer, ice::usize offset, ice::ualign align ) -> void const *

inlinenoexcept

Returns

'pointer' value advanced by the number of 'offset' bytes and aligned to the given 'alignment'

ptr_distance()

auto ice::ptr_distance ( void const * ptr_from, void const * ptr_to ) -> ice::usize

inlinenoexcept

Returns

'distance' between the given pointers.

ptr_offset()

auto ice::ptr_offset ( void const * ptr_from, void const * ptr_to ) -> ice::isize

inlinenoexcept

ptr_sub() [1/2]

auto ice::ptr_sub ( void * pointer, ice::usize offset ) -> void *

inlinenoexcept

Returns

'pointer' value retracted by the number of 'offset' bytes.

ptr_sub() [2/2]

auto ice::ptr_sub ( void const * pointer, ice::usize offset ) -> void const *

inlinenoexcept

Returns

'pointer' value retracted by the number of 'offset' bytes.

release()

void ice::release ( void * pointer )

noexcept

release_aligned()

void ice::release_aligned ( void * pointer )

noexcept

resume_on()

auto ice::resume_on ( ice::TaskScheduler & scheduler )

inlinenoexcept

schedule_queue() [1/2]

bool ice::schedule_queue ( ice::TaskQueue & queue, ice::TaskScheduler & scheduler )

noexcept

schedule_queue() [2/2]

bool ice::schedule_queue ( ice::TaskQueue & queue, void * result_ptr, ice::TaskScheduler & scheduler )

noexcept

schedule_task()

bool ice::schedule_task ( ice::Task<> task, ice::TaskScheduler & scheduler )

noexcept

schedule_tasks()

bool ice::schedule_tasks ( ice::Span< ice::Task<> > tasks, ice::TaskScheduler & scheduler )

noexcept

search() [1/2]

template<typename T, typename Comp, typename U = T>

bool ice::search ( ice::Span< T > values, U const & value, Comp && comp, ice::u32 & out_index )

constexprnoexcept

search() [2/2]

template<typename T, typename U = T>
requires (std::convertible_to<T, U>)

bool ice::search ( ice::Span< T > values, U const & value, ice::u32 & out_index )

constexprnoexcept

search_with()

template<typename T, typename Comp, typename... U>

bool ice::search_with ( ice::Span< T > values, Comp && comp, ice::u32 & out_index, U const &... params )

constexprnoexcept

shard() [1/5]

auto ice::shard ( ice::ShardID id ) -> ice::Shard

constexprnoexcept

Creates a ice::Shard value from ice::ShardID. Clears the payload ID from the created shard.

shard() [2/5]

template<typename T>

auto ice::shard ( ice::ShardID id, T payload ) -> ice::Shard

constexprnoexcept

Creates a ice::Shard value from ice::ShardID and the given value.

The function returns the final shard if both the shardid and the typeid of the given value match. Otherwise the shard fails to create.

Parameters

[in]	id	ShardID used to create the shard.
[in]	value	A value with a type enabled for sharding with ice::Constant_ShardPayloadID.

shard() [3/5]

template<typename T>
requires ice::HasShardPayloadID<T>

auto ice::shard ( ice::ShardID id, T payload ) -> ice::Shard

constexprnoexcept

Creates a ice::Shard value from ice::ShardID and the given value.

The function returns the final shard if both the shardid and the typeid of the given value match. Otherwise the shard fails to create.

Parameters

[in]	id	ShardID used to create the shard.
[in]	value	A value with a type enabled for sharding with ice::Constant_ShardPayloadID.

shard() [4/5]

template<typename T>

auto ice::shard ( std::string_view definition, T value )

constexprnoexcept

Creates a ice::Shard value from a utf8 string and the given value.

The function returns the final shard if both the definition and the typeid of the given value match. Otherwise the shard fails to create.

Parameters

[in]	definition	Follows the same rules described in ice::shardid(std::u8_string_view).
[in]	value	A value with a type enabled for sharding with ice::Constant_ShardPayloadID.

shard() [5/5]

template<typename T>
requires ice::HasShardPayloadID<T>

auto ice::shard ( std::string_view definition, T value )

constexprnoexcept

Creates a ice::Shard value from a utf8 string and the given value.

The function returns the final shard if both the definition and the typeid of the given value match. Otherwise the shard fails to create.

Parameters

[in]	definition	Follows the same rules described in ice::shardid(std::u8_string_view).
[in]	value	A value with a type enabled for sharding with ice::Constant_ShardPayloadID.

shard_inspect() [1/2]

template<typename T>

bool ice::shard_inspect ( ice::Shard shard, T & payload )

constexprnoexcept

Tries to read the value from the given shard.

Parameters

[out]

payload

A reference where the payload should be stored.

Returns

false If the types are not matching, or there is no payload value in the shard.

shard_inspect() [2/2]

template<typename T>
requires ice::HasShardPayloadID<T>

bool ice::shard_inspect ( ice::Shard shard, T & payload )

constexprnoexcept

Tries to read the value from the given shard.

Parameters

[out]

payload

A reference where the payload should be stored.

Returns

false If the types are not matching, or there is no payload value in the shard.

shard_payloadid()

auto ice::shard_payloadid ( std::string_view sv ) -> ice::ShardPayloadID

constexprnoexcept

shard_shatter() [1/2]

template<typename T>
requires ice::HasShardPayloadID<T>

auto ice::shard_shatter ( ice::Shard shard, T fallback ) -> T

constexprnoexcept

Reads the value from the given shard or returns the fallback value.

Returns

The payload value or the fallback value.

shard_shatter() [2/2]

template<typename T>

auto ice::shard_shatter ( ice::Shard shard, T fallback ) -> T

constexprnoexcept

Reads the value from the given shard or returns the fallback value.

Returns

The payload value or the fallback value.

shardid() [1/2]

auto ice::shardid ( ice::Shard shard ) -> ice::ShardID

constexprnoexcept

Returns the ice::ShardID value of a shard.

Note

It's better to use this function, instead of accessing the Shard::id member directly to avoid breaking changes.

shardid() [2/2]

auto ice::shardid ( std::string_view definition ) -> ice::ShardID

constexprnoexcept

Creates a ice::ShardID value from a utf8 string.

The passed value can contain the name and typeid. To do so the names need to be separated by a '' <em>(backquote)</em> character. For example.: my-shardice::u32

Note

Even if you create a ice::ShardID with a typeid that is not enabled, it will not allow you to create a shard with such a value.

sort() [1/3]

template<typename K, typename V, typename Pred>

void ice::sort ( ice::Span< K > keys, ice::Span< V > values, Pred && pred )

inlinenoexcept

sort() [2/3]

template<typename T>

void ice::sort ( ice::Span< T > span )

inlinenoexcept

sort() [3/3]

template<typename T, typename Pred>

void ice::sort ( ice::Span< T > span, Pred && pred )

inlinenoexcept

sort_indices()

template<typename K, typename Pred>

void ice::sort_indices ( ice::Span< K > keys, ice::Span< ice::u32 > indices, Pred && pred )

inlinenoexcept

sort_linked_list()

template<typename Node, typename Pred>

auto ice::sort_linked_list ( Node * left_list, ice::u32 size, Pred && pred ) -> Node *

inlinenoexcept

sort_many()

template<typename Key, typename Pred, typename... Values>
requires ice::concepts::ComparisonFunction<Pred, Key, Key>

void ice::sort_many ( ice::Span< Key > keys, Pred && pred, ice::Span< Values >... values )

inlinenoexcept

Span() [1/4]

template<typename T, ContainerLogic Logic, template< typename, ContainerLogic > typename Container>

ice::Span ( Container< T, Logic > const & ) -> Span< T >

noexcept

Span() [2/4]

template<typename T>

ice::Span ( ice::Span< T > && ) -> Span< T >

noexcept

Span() [3/4]

template<typename T>

ice::Span ( ice::Span< T > const & ) -> Span< T >

noexcept

Span() [4/4]

template<typename T, ice::u64 Size>

ice::Span ( T(&) [Size] ) -> Span< T >

noexcept

string_from_data() [1/2]

template<typename CharType, typename T>
requires ice::concepts::RODataObject<T>

auto ice::string_from_data ( T ro_data ) -> ice::BasicString< CharType >

constexprnoexcept

string_from_data() [2/2]

template<typename CharType, typename T>
requires ice::concepts::RODataObject<T>

auto ice::string_from_data ( T ro_data, ice::nindex offset, ice::ncount size ) -> ice::BasicString< CharType >

constexprnoexcept

stringid() [1/4]

auto ice::stringid ( const char * string, size_t size )

constexprnoexcept

stringid() [2/4]

template<ice::u32 Capacity = 12>

auto ice::stringid ( ice::StaticString< Capacity, char > value ) -> ice::StringID

constexprnoexcept

stringid() [3/4]

auto ice::stringid ( ice::String value ) -> ice::StringID

constexprnoexcept

stringid() [4/4]

auto ice::stringid ( std::string_view value )

constexprnoexcept

stringid_hash()

template<bool HasDebugInfo>

auto ice::stringid_hash ( ice::BaseStringID< HasDebugInfo > val ) -> ice::detail::stringid_type_v3::StringID_Hash

constexprnoexcept

stringid_hint() [1/2]

auto ice::stringid_hint ( ice::BaseStringID< false > val ) -> std::string_view

constexprnoexcept

stringid_hint() [2/2]

auto ice::stringid_hint ( ice::BaseStringID< true > const & val ) -> std::string_view

constexprnoexcept

to_const()

template<typename T>

auto ice::to_const ( T * value ) -> T const *

constexprnoexcept

upper_bound() [1/2]

template<typename T, typename U = T>
requires (std::convertible_to<T, U>)

auto ice::upper_bound ( ice::Span< T > values, U const & value ) -> ice::u32

constexprnoexcept

upper_bound() [2/2]

template<typename T, typename Comp, typename U = T>
requires (std::convertible_to<T, U>)

auto ice::upper_bound ( ice::Span< T > values, U const & value, Comp && comp ) -> ice::u32

constexprnoexcept

utf8_to_wide()

auto ice::utf8_to_wide ( ice::Allocator & alloc, ice::String path ) -> ice::HeapString< ice::wchar >

noexcept

utf8_to_wide_append()

bool ice::utf8_to_wide_append ( ice::String path, ice::HeapString< ice::wchar > & out_str )

noexcept

utf8_to_wide_size()

auto ice::utf8_to_wide_size ( ice::String path ) -> ice::u32

noexcept

value_or_default() [1/3]

template<typename T, typename U = T>
requires (std::convertible_to<U*, T*>)

auto ice::value_or_default ( T * value, U * default_value ) -> T *

constexprnoexcept

value_or_default() [2/3]

template<typename T, typename U = T>
requires (std::convertible_to<U, T> && std::is_arithmetic_v<T>)

auto ice::value_or_default ( T value, U && default_value ) -> T

constexprnoexcept

value_or_default() [3/3]

template<typename T, typename U = T>
requires (std::convertible_to<U, T>)

auto ice::value_or_default ( T value, U default_value ) -> T=delete

constexprdeletenoexcept

wait_for() [1/2]

void ice::wait_for ( ice::Span< ice::Task<> > tasks )

noexcept

wait_for() [2/2]

void ice::wait_for ( ice::Task<> task )

noexcept

wait_for_expected()

template<typename T>

auto ice::wait_for_expected ( ice::TaskExpected< T > task ) -> ice::Expected< T >

inlinenoexcept

wait_for_result() [1/3]

template<typename T>

void ice::wait_for_result ( ice::Span< ice::Task< T > > tasks, ice::Span< T > out_results )

inlinenoexcept

wait_for_result() [2/3]

template<typename T>

auto ice::wait_for_result ( ice::Task< T > task ) -> T

inlinenoexcept

wait_for_result() [3/3]

template<typename T>

void ice::wait_for_result ( ice::Task< T > task, T & out_result )

inlinenoexcept

wait_for_result_scheduled() [1/2]

template<typename T>

void ice::wait_for_result_scheduled ( ice::Span< ice::Task< T > > tasks, ice::TaskScheduler & scheduler, ice::Span< T > out_results )

inlinenoexcept

wait_for_result_scheduled() [2/2]

template<typename T>

void ice::wait_for_result_scheduled ( ice::Task< T > task, ice::TaskScheduler & scheduler, T & out_result )

inlinenoexcept

wait_for_scheduled() [1/2]

void ice::wait_for_scheduled ( ice::Span< ice::Task<> > tasks, ice::TaskScheduler & scheduler )

noexcept

wait_for_scheduled() [2/2]

void ice::wait_for_scheduled ( ice::Task<> task, ice::TaskScheduler & scheduler )

noexcept

wide_to_utf8()

auto ice::wide_to_utf8 ( ice::Allocator & alloc, ice::WString path ) -> ice::HeapString<>

noexcept

wide_to_utf8_append()

bool ice::wide_to_utf8_append ( ice::WString path, ice::HeapString<> & out_str )

noexcept

wide_to_utf8_size()

auto ice::wide_to_utf8_size ( ice::WString path ) -> ice::u32

noexcept

Variable Documentation

align_of

template<typename T>

ice::ualign ice::align_of = static_cast<ice::ualign>(alignof(T))

constexpr

Constant_DefaultContainerLogic

template<typename Type>

ice::ContainerLogic ice::Constant_DefaultContainerLogic

staticconstexpr

Initial value:

                                                                = (std::is_pod_v<Type> || std::is_enum_v<Type>)
? ContainerLogic::Trivial
: ContainerLogic::Complex

A helper used to pick the desired logic when it comes to handling data in collections.

Note

Only plain-old-data types use trivial collection logic by default.

Constant_IsTaskFlagsEnumeration

template<typename Enum>

bool ice::Constant_IsTaskFlagsEnumeration = false

staticconstexpr

Enables an enum type to be accepted as a task enumeration.

Constant_ShardPayloadID

template<typename T>

ice::ShardPayloadID ice::Constant_ShardPayloadID = ice::ShardPayloadID_NotSet

staticconstexpr

Constant_ShardPayloadID< bool >

template<>

ice::ShardPayloadID ice::Constant_ShardPayloadID< bool > = ice::shard_payloadid("bool")

inlineconstexpr

Constant_ShardPayloadID< char const * >

template<>

ice::ShardPayloadID ice::Constant_ShardPayloadID< char const * > = ice::shard_payloadid("char const*")

inlineconstexpr

Constant_ShardPayloadID< ice::f32 >

template<>

ice::ShardPayloadID ice::Constant_ShardPayloadID< ice::f32 > = ice::shard_payloadid("ice::f32")

inlineconstexpr

Constant_ShardPayloadID< ice::f64 >

template<>

ice::ShardPayloadID ice::Constant_ShardPayloadID< ice::f64 > = ice::shard_payloadid("ice::f64")

inlineconstexpr

Constant_ShardPayloadID< ice::i32 >

template<>

ice::ShardPayloadID ice::Constant_ShardPayloadID< ice::i32 > = ice::shard_payloadid("ice::i32")

inlineconstexpr

Constant_ShardPayloadID< ice::i64 >

template<>

ice::ShardPayloadID ice::Constant_ShardPayloadID< ice::i64 > = ice::shard_payloadid("ice::i64")

inlineconstexpr

Constant_ShardPayloadID< ice::String const * >

template<>

ice::ShardPayloadID ice::Constant_ShardPayloadID< ice::String const * > = ice::shard_payloadid("ice::String const*")

inlineconstexpr

Constant_ShardPayloadID< ice::StringID_Hash >

template<>

ice::ShardPayloadID ice::Constant_ShardPayloadID< ice::StringID_Hash > = ice::shard_payloadid("ice::StringID_Hash")

inlineconstexpr

Constant_ShardPayloadID< ice::Tns >

template<>

ice::ShardPayloadID ice::Constant_ShardPayloadID< ice::Tns > = ice::shard_payloadid("ice::Tns")

inlineconstexpr

Constant_ShardPayloadID< ice::u32 >

template<>

ice::ShardPayloadID ice::Constant_ShardPayloadID< ice::u32 > = ice::shard_payloadid("ice::u32")

inlineconstexpr

Constant_ShardPayloadID< ice::u64 >

template<>

ice::ShardPayloadID ice::Constant_ShardPayloadID< ice::u64 > = ice::shard_payloadid("ice::u64")

inlineconstexpr

Constant_ShardPayloadID< ice::vec2f >

template<>

ShardPayloadID ice::Constant_ShardPayloadID< ice::vec2f > = ice::shard_payloadid("ice::vec2f")

inlineconstexpr

Constant_ShardPayloadID< ice::vec2i >

template<>

ShardPayloadID ice::Constant_ShardPayloadID< ice::vec2i > = ice::shard_payloadid("ice::vec2i")

inlineconstexpr

Constant_ShardPayloadID< ice::vec2u >

template<>

ShardPayloadID ice::Constant_ShardPayloadID< ice::vec2u > = ice::shard_payloadid("ice::vec2u")

inlineconstexpr

Constant_ShardPayloadID< std::string_view const * >

template<>

ice::ShardPayloadID ice::Constant_ShardPayloadID< std::string_view const * > = ice::shard_payloadid("std::string_view const*")

inlineconstexpr

Constant_TaskFlagHighPrioValue

TaskFlagBaseType ice::Constant_TaskFlagHighPrioValue = 0x8

staticconstexpr

Constant_TaskFlagLongValue

TaskFlagBaseType ice::Constant_TaskFlagLongValue = 0x1

staticconstexpr

Enumeration values used in the engine explicitly.

Constant_TaskFlagLowPrioValue

TaskFlagBaseType ice::Constant_TaskFlagLowPrioValue = 0x2

staticconstexpr

Constant_TaskFlagNormalPrioValue

TaskFlagBaseType ice::Constant_TaskFlagNormalPrioValue = 0x4

staticconstexpr

E_ConfigIndexOutOfBounds

ice::ErrorCode ice::E_ConfigIndexOutOfBounds { "E.2211:Config:Config index was out-of-bounds." }

staticconstexpr

E_ConfigIsInvalid

ice::ErrorCode ice::E_ConfigIsInvalid { "E.2210:Config:Config is invalid." }

staticconstexpr

E_ConfigKeyNotFound

ice::ErrorCode ice::E_ConfigKeyNotFound { "E.2211:Config:Config key was not found." }

staticconstexpr

E_ConfigValueInvalid

ice::ErrorCode ice::E_ConfigValueInvalid { "E.2215:Config:Config value is not valid." }

staticconstexpr

E_ConfigValueNotAnObject

ice::ErrorCode ice::E_ConfigValueNotAnObject { "E.2217:Config:Config value is not an object." }

staticconstexpr

E_ConfigValueNotAnTable

ice::ErrorCode ice::E_ConfigValueNotAnTable { "E.2216:Config:Config value is not a table." }

staticconstexpr

E_ConfigValueTypeMissmatch

ice::ErrorCode ice::E_ConfigValueTypeMissmatch { "E.2218:Config:Config value type does not match the requested type." }

staticconstexpr

E_Error

ice::ErrorCodeError ice::E_Error = E_Fail

staticconstexpr

E_Fail

ice::ErrorCodeError ice::E_Fail { "E.0001:General:Unknown error" }

staticconstexpr

E_InvalidArgument

ice::ErrorCode ice::E_InvalidArgument { "E.0002:General:Invalid argument provided" }

staticconstexpr

E_NotImplemented

ice::ErrorCode ice::E_NotImplemented { "E.0004:General:Function or method is not implemented" }

staticconstexpr

E_NullPointer

ice::ErrorCode ice::E_NullPointer { "E.0005:General:Passed '{nullptr}' to function expecting valid pointer." }

staticconstexpr

E_NullPointerData

ice::ErrorCode ice::E_NullPointerData { "E.0006:General:Passed 'Data{nullptr}' object to function expecting valid data." }

staticconstexpr

E_NullPointerMemory

ice::ErrorCode ice::E_NullPointerMemory { "E.0007:General:Passed 'Memory{nullptr}' object to function expecting valid memory." }

staticconstexpr

E_OutOfRange

ice::ErrorCode ice::E_OutOfRange { "E.0003:General:Accessing value out of range" }

staticconstexpr

E_TaskCanceled

ice::ErrorCode ice::E_TaskCanceled { "E.1001:Tasks:Task canceled" }

staticconstexpr

f32_0

ice::f32 const ice::f32_0 = ice::f32(0.0f)

constexpr

f32_inf

ice::f32 const ice::f32_inf = std::numeric_limits<ice::f32>::infinity()

constexpr

f32_max

ice::f32 const ice::f32_max = std::numeric_limits<ice::f32>::max()

constexpr

f32_min

ice::f32 const ice::f32_min = std::numeric_limits<ice::f32>::min()

constexpr

f32_nan

ice::f32 const ice::f32_nan = std::numeric_limits<ice::f32>::signaling_NaN()

constexpr

f64_0

ice::f64 const ice::f64_0 = ice::f64(0.0)

constexpr

f64_inf

ice::f64 const ice::f64_inf = std::numeric_limits<ice::f64>::infinity()

constexpr

f64_max

ice::f64 const ice::f64_max = std::numeric_limits<ice::f64>::max()

constexpr

f64_min

ice::f64 const ice::f64_min = std::numeric_limits<ice::f64>::min()

constexpr

f64_nan

ice::f64 const ice::f64_nan = std::numeric_limits<ice::f64>::signaling_NaN()

constexpr

Global_NullAllocator

NullAllocator ice::Global_NullAllocator {}

static

i16_0

ice::i16 const ice::i16_0 = ice::i16(0)

constexpr

i16_max

ice::i16 const ice::i16_max = std::numeric_limits<ice::i16>::max()

constexpr

i16_min

ice::i16 const ice::i16_min = std::numeric_limits<ice::i16>::min()

constexpr

i32_0

ice::i32 const ice::i32_0 = ice::i32(0)

constexpr

i32_max

ice::i32 const ice::i32_max = std::numeric_limits<ice::i32>::max()

constexpr

i32_min

ice::i32 const ice::i32_min = std::numeric_limits<ice::i32>::min()

constexpr

i64_0

ice::i64 const ice::i64_0 = ice::i64(0)

constexpr

i64_max

ice::i64 const ice::i64_max = std::numeric_limits<ice::i64>::max()

constexpr

i64_min

ice::i64 const ice::i64_min = std::numeric_limits<ice::i64>::min()

constexpr

i8_0

ice::i8 const ice::i8_0 = ice::i8(0)

constexpr

i8_max

ice::i8 const ice::i8_max = std::numeric_limits<ice::i8>::max()

constexpr

i8_min

ice::i8 const ice::i8_min = std::numeric_limits<ice::i8>::min()

constexpr

is_field_member_v

template<typename Member>

bool ice::is_field_member_v = member_info<Member>::member_type == 2

constexpr

is_method_member_v

template<typename Member>

bool ice::is_method_member_v = member_info<Member>::member_type == 1

constexpr

is_type_complete

template<typename T, typename = void>

bool ice::is_type_complete = false

constexpr

is_type_complete< T, std::void_t< decltype(sizeof(T))> >

template<typename T>

bool ice::is_type_complete< T, std::void_t< decltype(sizeof(T))> > = true

constexpr

lowest_compiled_log_severity

LogSeverity ice::lowest_compiled_log_severity

staticconstexpr

Initial value:

                                                          = []() -> ice::LogSeverity
{
    if constexpr (ice::build::is_debug)
    {
        return LogSeverity::Debug;
    }
    else if constexpr (ice::build::is_release)
    {
        return LogSeverity::Retail;
    }
    else
    {
        return LogSeverity::Verbose;
    }
}()

meminfo_of

template<typename T>

ice::meminfo ice::meminfo_of = { ice::size_of<T>, ice::align_of<T> }

constexpr

ncount_max

ice::ncount ice::ncount_max { ice::detail::nvalue_max_value() }

staticconstexpr

ncount_min

ice::ncount ice::ncount_min { ice::detail::nvalue_min_value() }

staticconstexpr

ncount_none

ice::ncount_invalid_t ice::ncount_none { }

staticconstexpr

nindex_max

ice::nindex ice::nindex_max { ice::detail::nvalue_max_value() }

staticconstexpr

nindex_min

ice::nindex ice::nindex_min { ice::detail::nvalue_min_value() }

staticconstexpr

nindex_none

ice::nindex_invalid_t ice::nindex_none { }

staticconstexpr

S_Ok

ice::ErrorCodeSuccess ice::S_Ok { "S.0000:General:Success" }

staticconstexpr

S_Success

ice::ErrorCodeSuccess ice::S_Success = S_Ok

staticconstexpr

Shard_Invalid

ice::Shard ice::Shard_Invalid { .id = { }, .payload = { } }

staticconstexpr

ShardPayloadID_NotSet

ice::ShardPayloadID ice::ShardPayloadID_NotSet = { 0 }

staticconstexpr

size_of

template<typename T>

ice::usize ice::size_of = { sizeof(T) }

constexpr

StringID_Invalid

ice::StringID ice::StringID_Invalid { .value = StringID_Hash{ } }

staticconstexpr

t0

ice::detail::TTLowestPrecisionType<Tms, Tus> ice::t0 { 1 }

staticconstexpr

t1

Tns ice::t1 = t0

staticconstexpr

Test_Meminfo

ice::meminfo ice::Test_Meminfo = ice::meminfo_of<ice::ncount>

staticconstexpr

u16_0

ice::u16 const ice::u16_0 = ice::u16(0)

constexpr

u16_max

ice::u16 const ice::u16_max = std::numeric_limits<ice::u16>::max()

constexpr

u16_min

ice::u16 const ice::u16_min = std::numeric_limits<ice::u16>::min()

constexpr

u32_0

ice::u32 const ice::u32_0 = ice::u32(0)

constexpr

u32_max

ice::u32 const ice::u32_max = std::numeric_limits<ice::u32>::max()

constexpr

u32_min

ice::u32 const ice::u32_min = std::numeric_limits<ice::u32>::min()

constexpr

u64_0

ice::u64 const ice::u64_0 = ice::u64(0)

constexpr

u64_max

ice::u64 const ice::u64_max = std::numeric_limits<ice::u64>::max()

constexpr

u64_min

ice::u64 const ice::u64_min = std::numeric_limits<ice::u64>::min()

constexpr

u8_0

ice::u8 const ice::u8_0 = ice::u8(0)

constexpr

u8_max

ice::u8 const ice::u8_max = std::numeric_limits<ice::u8>::max()

constexpr

u8_min

ice::u8 const ice::u8_min = std::numeric_limits<ice::u8>::min()

constexpr