AZ namespace needs to be closed in order to specialize the AZStd::hash struct for AddressTypeElement and AddressType. More...

Classes
struct	adopt_lock_t

class	allocator

class	allocator_ref

struct	allocator_traits

struct	alphanum_less
	Functor class to compare two objects with the "Alphanum Algorithm". More...

class	any

class	array

class	array< T, 0U >

class	BackTracingState

struct	basic_common_reference

struct	basic_common_reference< pair< T1, T2 >, pair< U1, U2 >, TQual, UQual >

struct	basic_common_reference< tuple< TTypes... >, tuple< UTypes... >, TQual, UQual >

class	basic_const_iterator

class	basic_fixed_string

class	basic_regex

class	basic_string

class	basic_string_view

class	binary_semaphore

struct	bit_and

struct	bit_and< void >

struct	bit_not

struct	bit_not< void >

struct	bit_or

struct	bit_or< void >

struct	bit_xor

struct	bit_xor< void >

class	bitset

class	Builder

struct	call_max_size

struct	call_max_size< Allocator, ValueType, SizeType, false, true >

struct	call_max_size< Allocator, ValueType, SizeType, true, get_max_size_callable >

struct	call_select_on_container_copy_construction

struct	call_select_on_container_copy_construction< Allocator, true >

struct	char_traits

struct	checked_array_deleter

struct	checked_deleter

struct	ClassNames

struct	CmpCollate

struct	CmpCS

struct	CmpIcase

class	combinable

class	common_iterator

class	common_iterator< I, S, enable_if_t< conjunction_v< bool_constant< input_or_output_iterator< I > >, bool_constant< sentinel_for< S, I > >, bool_constant<!same_as< I, S > >, bool_constant< copyable< I > > > > >

struct	common_reference

class	compressed_pair

struct	compressed_pair_element

struct	compressed_pair_element< T, Index, true >

class	concurrent_fixed_unordered_map

class	concurrent_fixed_unordered_multimap

class	concurrent_fixed_unordered_multiset

class	concurrent_fixed_unordered_set

class	concurrent_unordered_map

class	concurrent_unordered_multimap

class	concurrent_unordered_multiset

class	concurrent_unordered_set

class	concurrent_vector

class	condition_variable

class	condition_variable_any

struct	contiguous_iterator_tag
	Identifying tag for contagious iterators. More...

class	counted_iterator

struct	default_delete

struct	default_delete< T[]>

struct	default_destruct

struct	default_sentinel_t
	Add the default_sentinel struct from C++20. More...

struct	defer_lock_t

class	delegate

class	delegate< R(Param1) >

class	delegate< R(Param1, Param2) >

class	delegate< R(Param1, Param2, Param3) >

class	delegate< R(Param1, Param2, Param3, Param4) >

class	delegate< R(Param1, Param2, Param3, Param4, Param5) >

class	delegate< R(Param1, Param2, Param3, Param4, Param5, Param6) >

class	delegate< R(Param1, Param2, Param3, Param4, Param5, Param6, Param7) >

class	delegate< R(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8) >

class	delegate_memento

class	deque

struct	deque_block

class	deque_iterator_impl

struct	divides

struct	divides< void >

class	enable_shared_from_this

class	enable_shared_from_this2

struct	endian_swap_impl

struct	endian_swap_impl< T, 1 >

struct	endian_swap_impl< T, 2 >

struct	endian_swap_impl< T, 4 >

struct	endian_swap_impl< T, 8 >

struct	equal_to

struct	equal_to< void >

class	expected

class	exponential_backoff

struct	find_exactly_one_alternative

struct	find_exactly_one_variadic

struct	find_exactly_one_variadic< T >

class	fixed_forward_list

class	fixed_list

class	fixed_unordered_map

class	fixed_unordered_multimap

class	fixed_unordered_multiset

class	fixed_unordered_set

class	fixed_vector

class	forward_list

class	forward_list_iterator

struct	from_range_t

class	function

class	function< R(Args...)>

class	function_base

class	function_intermediate

struct	function_traits

struct	get_align_type
	align_type

struct	get_align_type< Allocator, AlignType, void_t< typename Allocator::align_type > >

struct	get_const_pointer_type
	const_pointer

struct	get_const_pointer_type< Allocator, PointerType, ValueType, void_t< typename Allocator::const_pointer > >

struct	get_const_void_pointer_type
	const_void_pointer

struct	get_const_void_pointer_type< Allocator, PointerType, void_t< typename Allocator::const_void_pointer > >

struct	get_difference_type
	difference_type

struct	get_difference_type< Allocator, PointerType, void_t< typename Allocator::difference_type > >

struct	get_is_always_equal_type
	is_always_equal

struct	get_is_always_equal_type< Allocator, void_t< typename Allocator::is_always_equal > >

struct	get_pointer_type

struct	get_pointer_type< Allocator, ValueType, false, true >

struct	get_pointer_type< Allocator, ValueType, true, has_azstd_pointer_alias >

struct	get_propagate_on_container_copy_assignment_type
	propagate_on_container_copy_assignment

struct	get_propagate_on_container_copy_assignment_type< Allocator, void_t< typename Allocator::propagate_on_container_copy_assignment > >

struct	get_propagate_on_container_move_assignment_type
	propagate_on_container_move_assignment

struct	get_propagate_on_container_move_assignment_type< Allocator, void_t< typename Allocator::propagate_on_container_move_assignment > >

struct	get_propagate_on_container_swap_type
	propagate_on_container_swap

struct	get_propagate_on_container_swap_type< Allocator, void_t< typename Allocator::propagate_on_container_swap > >

struct	get_rebind_type
	allocator_type is not a template nor does it have a rebind alias template therefore the allocator_type will be used directly

struct	get_rebind_type< Allocator, NewType, true >
	allocator_type has rebind alias template, so it will be used

struct	get_rebind_type< Allocator< T, Args... >, NewType, false >
	allocator_type is a class template and does not have rebind alias template so replace the first argument with the new type

struct	get_size_type
	size_type

struct	get_size_type< Allocator, DifferenceType, void_t< typename Allocator::size_type > >

struct	get_value_type
	value_type

struct	get_value_type< Allocator, void_t< typename Allocator::value_type > >

struct	get_void_pointer_type
	void_pointer

struct	get_void_pointer_type< Allocator, PointerType, void_t< typename Allocator::void_pointer > >

struct	greater

struct	greater< void >

struct	greater_equal

struct	greater_equal< void >

struct	HandleLambdaPointer

struct	HandleLambdaPointer< R(L::*)(Args...) const >

struct	HandleLambdaPointer< R(L::*)(Args...)>

struct	has_rebind
	rebind

struct	has_rebind< Allocator, NewType, void_t< typename Allocator::template rebind< NewType >::other > >

struct	hash
	Default template (just try to cast the value to size_t) More...

struct	hash< AZ::Crc32 >

struct	hash< AZ::Data::Asset< AZ::SliceAsset > >

struct	hash< AZ::Data::AssetContainerKey >

struct	hash< AZ::Data::AssetId >

struct	hash< AZ::DataOverlayInstanceId >

struct	hash< AZ::EntityId >

struct	hash< AZ::IO::BasicPath< StringType > >

struct	hash< AZ::IO::PathView >

struct	hash< AZ::SliceComponent::SliceInstanceAddress >

struct	hash< AZ::Uuid >

struct	hash< AZStd::pair< T, U > >

struct	hash< AZStd::tuple< Types... > >

struct	hash< basic_fixed_string< Element, MaxElementCount, Traits > >

struct	hash< basic_string< Element, Traits, Allocator > >

struct	hash< basic_string_view< Element, Traits > >

struct	hash< const T * >

struct	hash< const T[N] >

struct	hash< double >

struct	hash< float >

struct	hash< intrusive_ptr< T > >

struct	hash< long double >

struct	hash< monostate >

struct	hash< optional< T > >

struct	hash< T * >

struct	hash< T[N] >

struct	hash< thread_id >

struct	hash< unique_ptr< T, Deleter > >

struct	hash< variant< Types... > >

class	hash_node_destructor

class	hash_table

struct	identity

struct	incrementable_traits

struct	incrementable_traits< common_iterator< I, S > >

struct	incrementable_traits< const T >

struct	incrementable_traits< projected< I, Proj >, enable_if_t< weakly_incrementable< I > > >

struct	incrementable_traits< T * >

struct	indirectly_readable_traits

struct	indirectly_readable_traits< const T >

struct	indirectly_readable_traits< T * >

struct	insert_return_type

struct	intrusive_default_delete

class	intrusive_list

struct	intrusive_list_node

class	intrusive_multiset

struct	intrusive_multiset_base_hook

struct	intrusive_multiset_member_hook

struct	intrusive_multiset_node

class	intrusive_ptr

class	intrusive_refcount

class	intrusive_slist

struct	intrusive_slist_node

struct	IntrusivePtrCountPolicy

struct	invoke_result

struct	is_bounded_array

struct	is_bounded_array< T[N]>

struct	is_function_pointer

struct	is_invocable

struct	is_invocable_r

struct	is_nothrow_invocable

struct	is_nothrow_invocable_r

class	is_reference_wrapper

struct	is_type_safe_integral

struct	is_unbounded_array

struct	is_unbounded_array< T[]>

struct	IsNumber

struct	IsNumber< T, true >

struct	iterator_traits

struct	iterator_traits< back_insert_iterator< Container > >

struct	iterator_traits< common_iterator< I, S > >

struct	iterator_traits< front_insert_iterator< Container > >

struct	iterator_traits< insert_iterator< Container > >

struct	iterator_traits< T * >

struct	less

struct	less< void >

struct	less_equal

struct	less_equal< void >

class	list

struct	list_base_hook

class	list_iterator

struct	list_member_hook

class	lock_free_intrusive_stack

struct	lock_free_intrusive_stack_base_hook

struct	lock_free_intrusive_stack_member_hook

struct	lock_free_intrusive_stack_node

class	lock_free_intrusive_stamped_stack

class	lock_free_queue

class	lock_free_stack

class	lock_free_stamped_queue

class	lock_free_stamped_stack

class	lock_guard

struct	logical_and

struct	logical_and< void >

struct	logical_not

struct	logical_not< void >

struct	logical_or

struct	logical_or< void >

struct	LoopValues

struct	make_void

class	map

struct	map_node_base

struct	map_node_traits

class	match_results

class	Matcher

struct	minus

struct	minus< void >

struct	modulus

struct	modulus< void >

struct	monostate

class	move_iterator

class	move_sentinel

class	multimap

struct	multiplies

struct	multiplies< void >

class	multiset

class	mutex

struct	native_thread_data_type

struct	negate

struct	negate< void >

class	no_default_allocator

struct	no_delete

struct	no_destruct

class	node_handle

class	NodeAssert

class	NodeBack

class	NodeBase

class	NodeCapture

class	NodeClass

class	NodeEndGroup

class	NodeEndif

class	NodeEndRepetition

class	NodeIf

class	NodeRepetition

class	NodeString

struct	not_equal_to

struct	not_equal_to< void >

struct	pair

class	Parser

struct	piecewise_construct_t

struct	plus

struct	plus< void >

struct	projected

struct	projected< I, Proj, enable_if_t< conjunction_v< bool_constant< indirectly_readable< I > >, bool_constant< indirectly_regular_unary_invocable< Proj, I > > > > >

class	rbtree

class	rbtree_const_iterator

class	rbtree_iterator

class	rbtree_node_destructor

class	recursive_mutex

class	regex_iterator

class	regex_token_iterator

class	regex_traits

class	regex_traits< char >

class	regex_traits< wchar_t >

struct	RegExBitmap

struct	RegExBuffer

struct	RegExSequence

class	RegexTraits

struct	RegexTraitsBase

struct	remove_cvref

struct	RemoveEnum

struct	RemoveEnum< T, false >

struct	RemoveFunctionConst

struct	RemoveFunctionConst< R(Args...)>

struct	RemoveFunctionConst< R(C::*)(Args...) const >

struct	RemoveFunctionConst< R(C::*)(Args...)>

class	ring_buffer

class	RootNode

class	scoped_array

class	scoped_lock

class	scoped_lock< Mutex >

class	scoped_lock<>

class	scoped_ptr

class	semaphore

class	set

struct	set_node_base

struct	set_node_traits

class	shared_array

class	shared_lock

class	shared_mutex

class	shared_ptr

struct	skip_element_tag

struct	slist_base_hook

struct	slist_member_hook

class	span

class	spin_mutex

class	stack_allocator

class	stateless_allocator

class	static_buffer_allocator

class	static_pool_allocator

class	static_pool_concurrent_allocator

class	static_storage

class	sub_match

class	TgtState

class	thread

struct	thread_desc

struct	thread_id

class	ThreadEvents

struct	transfer_ownership_t
	distinguishes between any Extension constructor calls More...

struct	try_to_lock_t

struct	tuple_elements_sequence

struct	type_id_holder

struct	type_id_holder< T const >

struct	type_id_holder< T const volatile >

struct	type_id_holder< T volatile >

struct	type_identity

struct	unexpect_t
	Tag Type for in-place construction of the error type. More...

class	unexpected

class	unique_lock

class	unordered_map

class	unordered_multimap

class	unordered_multiset

class	unordered_set

struct	unreachable_sentinel_t

struct	unwrap_ref_decay

struct	unwrap_reference

struct	unwrap_reference< AZStd::reference_wrapper< T > >

class	upgrade_lock

class	variant

struct	variant_alternative

struct	variant_alternative< Index, const T >

struct	variant_alternative< Index, const volatile T >

struct	variant_alternative< Index, variant< Types... > >

struct	variant_alternative< Index, volatile T >

struct	variant_size

struct	variant_size< const T >

struct	variant_size< const volatile T >

struct	variant_size< variant< Types... > >

struct	variant_size< volatile T >

class	vector

class	weak_ptr

Typedefs
using	sys_time_t = AZ::s64

using	input_iterator_tag = std::input_iterator_tag
	Identifying tag for input iterators.

using	output_iterator_tag = std::output_iterator_tag
	Identifying tag for output iterators.

using	forward_iterator_tag = std::forward_iterator_tag
	Identifying tag for forward iterators.

using	bidirectional_iterator_tag = std::bidirectional_iterator_tag
	Identifying tag for bidirectional iterators.

using	random_access_iterator_tag = std::random_access_iterator_tag
	Identifying tag for random-access iterators.

template<class F , class... Is>
using	indirect_result_t = typename Internal::indirect_result< conjunction_v< bool_constant< indirectly_readable< Is > >..., bool_constant< AZStd::invocable< F, iter_reference_t< Is >... > > >, F, Is... >::type

template<class T , class Container = AZStd::deque<T>>
using	queue = std::queue< T, Container >

template<class T , class Container = AZStd::vector<T>, class Compare = AZStd::less<typename Container::value_type>>
using	priority_queue = std::priority_queue< T, Container, Compare >

template<class T , class Container = AZStd::deque<T>>
using	stack = std::stack< T, Container >

template<size_t Index, class T >
using	variant_alternative_t = typename variant_alternative< Index, T >::type

template<size_t NumAlternatives>
using	variant_index_t = AZStd::conditional_t<(NumAlternatives< std::numeric_limits< uint8_t >::max()), uint8_t, AZStd::conditional_t<(NumAlternatives< std::numeric_limits< uint16_t >::max()), uint16_t, AZStd::conditional_t<(NumAlternatives< std::numeric_limits< uint32_t >::max()), uint32_t, uint64_t > > >

template<class Fn , class... ArgTypes>
using	invoke_result_t = typename invoke_result< Fn, ArgTypes... >::type

template<class I >
using	const_iterator = enable_if_t< input_iterator< I >, conditional_t< Internal::constant_iterator< I >, I, basic_const_iterator< I > > >

template<class S >
using	const_sentinel = conditional_t< input_iterator< S >, const_iterator< S >, S >

template<typename T >
using	iter_value_t = typename indirectly_readable_traits< remove_cvref_t< T > >::value_type

template<typename T >
using	iter_reference_t = enable_if_t< Internal::dereferenceable< T >, decltype(*declval< T & >())>

template<typename T >
using	iter_difference_t = typename incrementable_traits< remove_cvref_t< T > >::difference_type

template<typename T >
using	iter_rvalue_reference_t = decltype(ranges::iter_move(declval< T & >()))

template<typename T >
using	iter_common_reference_t = enable_if_t< Internal::indirectly_readable_impl< T >, common_reference_t< iter_reference_t< T >, iter_value_t< T > & > >

template<class It >
using	iter_const_reference_t = enable_if_t< Internal::indirectly_readable_impl< It >, common_reference_t< const iter_value_t< It > &&, iter_reference_t< It > > >

using	atomic_char = std::atomic< char >

using	atomic_uchar = std::atomic< unsigned char >

using	atomic_wchar_t = std::atomic< wchar_t >

using	atomic_short = std::atomic< short >

using	atomic_ushort = std::atomic< unsigned short >

using	atomic_int = std::atomic< int >

using	atomic_uint = std::atomic< unsigned int >

using	atomic_long = std::atomic< long >

using	atomic_ulong = std::atomic< unsigned long >

using	atomic_llong = std::atomic< long long >

using	atomic_ullong = std::atomic< unsigned long long >

using	atomic_size_t = std::atomic< size_t >

using	atomic_ptrdiff_t = std::atomic< ptrdiff_t >

using	atomic_int8_t = std::atomic< int8_t >

using	atomic_uint8_t = std::atomic< uint8_t >

using	atomic_int16_t = std::atomic< int16_t >

using	atomic_uint16_t = std::atomic< uint16_t >

using	atomic_int32_t = std::atomic< int32_t >

using	atomic_uint32_t = std::atomic< uint32_t >

using	atomic_int64_t = std::atomic< int64_t >

using	atomic_uint64_t = std::atomic< uint64_t >

typedef AZ::EBus< ThreadEvents >	ThreadEventBus

template<class T >
using	unwrap_reference_t = typename unwrap_reference< T >::type

template<class T >
using	unwrap_ref_decay_t = typename unwrap_ref_decay< T >::type

using	intrusive_base = intrusive_refcount< atomic_uint >

template<size_t MaxElementCount>
using	fixed_string = basic_fixed_string< char, MaxElementCount, char_traits< char > >

template<size_t MaxElementCount>
using	fixed_wstring = basic_fixed_string< wchar_t, MaxElementCount, char_traits< wchar_t > >

typedef sub_match< const char * >	csub_match

typedef sub_match< const wchar_t * >	wcsub_match

typedef sub_match< string::const_iterator >	ssub_match

typedef sub_match< wstring::const_iterator >	wssub_match

typedef basic_regex< char >	regex

typedef basic_regex< wchar_t >	wregex

typedef match_results< const char * >	cmatch

typedef match_results< const wchar_t * >	wcmatch

typedef match_results< string::const_iterator >	smatch

typedef match_results< wstring::const_iterator >	wsmatch

typedef regex_iterator< const char * >	cregex_iterator

typedef regex_iterator< const wchar_t * >	wcregex_iterator

typedef regex_iterator< string::const_iterator >	sregex_iterator

typedef regex_iterator< wstring::const_iterator >	wsregex_iterator

typedef regex_token_iterator< const char * >	cregex_token_iterator

typedef regex_token_iterator< const wchar_t * >	wcregex_token_iterator

typedef regex_token_iterator< string::const_iterator >	sregex_token_iterator

typedef regex_token_iterator< wstring::const_iterator >	wsregex_token_iterator

typedef basic_string< char >	string

typedef basic_string< wchar_t >	wstring

using	string_view = basic_string_view< char >

using	wstring_view = basic_string_view< wchar_t >

template<class Type >
using	add_pointer_t = std::add_pointer_t< Type >

template<class T >
using	add_lvalue_reference_t = typename add_lvalue_reference< T >::type

template<class T >
using	add_rvalue_reference_t = typename add_rvalue_reference< T >::type

template<typename T , size_t Alignment = alignof(T)>
using	aligned_storage_for_t = std::aligned_storage_t< sizeof(T), Alignment >

template<class... T>
using	common_reference_t = typename common_reference< T... >::type

template<typename Function >
using	function_traits_get_result_t = typename function_traits< Function >::result_type

template<typename Function , size_t index>
using	function_traits_get_arg_t = typename function_traits< Function >::template get_arg_t< index >

template<class T >
using	remove_const_t = std::remove_const_t< T >

template<class T >
using	remove_cv_t = std::remove_cv_t< T >

template<typename T >
using	remove_cvref_t = typename remove_cvref< T >::type

template<class Type >
using	remove_pointer_t = std::remove_pointer_t< Type >

template<class T >
using	remove_reference_t = typename remove_reference< T >::type

template<class T >
using	remove_volatile_t = std::remove_volatile_t< T >

typedef void *	type_id

template<typename T >
using	type_identity_t = typename type_identity< T >::type

template<typename... Args>
using	void_t = typename make_void< Args... >::type

template<class T >
using	RemoveEnumT = typename RemoveEnum< T >::type

using	native_mutex_data_type = pthread_mutex_t

using	native_mutex_handle_type = pthread_mutex_t *

using	native_recursive_mutex_data_type = pthread_mutex_t

using	native_recursive_mutex_handle_type = pthread_mutex_t *

using	native_cond_var_data_type = pthread_cond_t

using	native_cond_var_handle_type = pthread_cond_t *

using	native_semaphore_data_type = sem_t

using	native_semaphore_handle_type = sem_t *

using	native_thread_id_type = pthread_t

using	native_thread_data_type = pthread_t

using	native_thread_handle_type = pthread_t

Enumerations
enum	iterator_status_flag { isf_none = 0x00 , isf_valid = 0x01 , isf_can_dereference = 0x02 , isf_current = 0x04 }

enum class	cv_status { no_timeout , timeout }

enum	MetaType { Meta_lpar = '(' , Meta_rpar = ')' , Meta_dlr = '$' , Meta_caret = '^' , Meta_dot = '.' , Meta_star = '' , Meta_plus* = '+' , Meta_query = '?' , Meta_lsq = '[' , Meta_rsq = ']' , Meta_bar = '\|' , Meta_esc = '\\' , Meta_dash = '-' , Meta_lbr = '{' , Meta_rbr = '}' , Meta_comma = ',' , Meta_colon = ':' , Meta_equal = '=' , Meta_exc = '!' , Meta_eos = -1 , Meta_nl = '\n' , Meta_cr = '\r' , Meta_bsp = '\b' , Meta_chr = 0 , Esc_bsl = '\\' , Esc_word = 'b' , Esc_not_word = 'B' , Esc_ctrl_a = 'a' , Esc_ctrl_b = 'b' , Esc_ctrl_f = 'f' , Esc_ctrl_n = 'n' , Esc_ctrl_r = 'r' , Esc_ctrl_t = 't' , Esc_ctrl_v = 'v' , Esc_ctrl = 'c' , Esc_hex = 'x' , Esc_uni = 'u' }

enum	NodeFlags { NFLG_none = 0x00 , NFLG_negate = 0x01 , NFLG_greedy = 0x02 , NFLG_final = 0x04 , NFLG_longest = 0x08 }

enum	NodeType { NT_none , NT_nop , NT_bol , NT_eol , NT_wbound , NT_dot , NT_str , NT_class , NT_group , NT_end_group , NT_assert , NT_neg_assert , NT_end_assert , NT_capture , NT_end_capture , NT_back , NT_if , NT_endif , NT_rep , NT_end_rep , NT_begin , NT_end }

enum	ParserClass { _Prs_none , _Prs_chr , _Prs_set }

enum	LanguageFlags { LF_ext_rep = 0x00000001 , LF_alt_pipe = 0x00000002 , LF_alt_nl = 0x00000004 , LF_nex_grp = 0x00000008 , LF_nex_rep = 0x00000010 , LF_nc_grp = 0x00000020 , LF_asrt_gen = 0x00000040 , LF_asrt_wrd = 0x00000080 , LF_bckr = 0x00000100 , LF_lim_bckr = 0x00000200 , LF_ngr_rep = 0x00000400 , LF_esc_uni = 0x00000800 , LF_esc_hex = 0x00001000 , LF_esc_oct = 0x00002000 , LF_esc_bsl = 0x00004000 , LF_esc_ffnx = 0x00008000 , LF_esc_ffn = 0x00010000 , LF_esc_wsd = 0x00020000 , LF_esc_ctrl = 0x00040000 , LF_no_nl = 0x00080000 , LF_bzr_chr = 0x00100000 , LF_grp_esc = 0x00200000 , LF_ident_ECMA = 0x00400000 , LF_ident_ERE = 0x00800000 , LF_ident_awk = 0x01000000 , LF_anch_rstr = 0x02000000 , LF_star_beg = 0x04000000 , LF_empty_grp = 0x08000000 , LF_paren_bal = 0x10000000 , LF_brk_rstr = 0x20000000 , LF_mtch_long = 0x40000000 , LF_no_subs = 0x80000000 }

Functions
AZCORE_API void	to_string (string &str, const AZ::Vector2 &value)
	Prints a Vector2 with precision to 8 decimal places.

AZCORE_API void	to_string (string &str, const AZ::Vector3 &value)
	Prints a Vector3 with precision to 8 decimal places.

AZCORE_API void	to_string (string &str, const AZ::Vector4 &value)
	Prints a Vector4 with precision to 8 decimal places.

AZCORE_API void	to_string (string &str, const AZ::Quaternion &value)
	Prints a Quaternion with precision to 8 decimal places.

AZCORE_API void	to_string (string &str, const AZ::Matrix3x3 &value)
	Prints a 3x3 matrix in row major order over three lines with precision to 8 decimal places.

AZCORE_API void	to_string (string &str, const AZ::Matrix4x4 &value)
	Prints a 4x4 matrix in row major order over four lines with precision to 8 decimal places.

AZCORE_API void	to_string (string &str, const AZ::Transform &value)
	Prints a transform as a 3x4 matrix in row major order over four lines with precision to 8 decimal places.

AZCORE_API void	to_string (string &str, const AZ::Aabb &value)
	Prints an AABB as a pair of Vector3s with precision to 8 decimal places.

AZCORE_API void	to_string (string &str, const AZ::Color &value)
	Prints a Color as four unsigned ints representing RGBA.

AZStd::string	to_string (const AZ::Vector2 &val)

AZStd::string	to_string (const AZ::Vector3 &val)

AZStd::string	to_string (const AZ::Vector4 &val)

AZStd::string	to_string (const AZ::Quaternion &val)

AZStd::string	to_string (const AZ::Matrix3x3 &val)

AZStd::string	to_string (const AZ::Matrix4x4 &val)

AZStd::string	to_string (const AZ::Transform &val)

AZStd::string	to_string (const AZ::Aabb &val)

AZStd::string	to_string (const AZ::Color &val)

	AZ_TYPE_INFO_SPECIALIZE_WITH_NAME_DECL_API (AZCORE_API, AZStd::monostate)

	AZ_TYPE_INFO_SPECIALIZE_WITH_NAME_DECL_API (AZCORE_API, AZStd::allocator)

	AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_POSTFIX_UUID (AZStd::less, "AZStd::less", "{41B40AFC-68FD-4ED9-9EC7-BA9992802E1B}", AZ_TYPE_INFO_INTERNAL_TYPENAME)

	AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_POSTFIX_UUID (AZStd::less_equal, "AZStd::less_equal", "{91CC0BDC-FC46-4617-A405-D914EF1C1902}", AZ_TYPE_INFO_INTERNAL_TYPENAME)

	AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_POSTFIX_UUID (AZStd::greater, "AZStd::greater", "{907F012A-7A4F-4B57-AC23-48DC08D0782E}", AZ_TYPE_INFO_INTERNAL_TYPENAME)

	AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_POSTFIX_UUID (AZStd::greater_equal, "AZStd::greater_equal", "{EB00488F-E20F-471A-B862-F1E3C39DDA1D}", AZ_TYPE_INFO_INTERNAL_TYPENAME)

	AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_POSTFIX_UUID (AZStd::equal_to, "AZStd::equal_to", "{4377BCED-F78C-4016-80BB-6AFACE6E5137}", AZ_TYPE_INFO_INTERNAL_TYPENAME)

	AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_POSTFIX_UUID (AZStd::hash, "AZStd::hash", "{EFA74E54-BDFA-47BE-91A7-5A05DA0306D7}", AZ_TYPE_INFO_INTERNAL_TYPENAME)

	AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_POSTFIX_UUID (AZStd::pair, "AZStd::pair", "{919645C1-E464-482B-A69B-04AA688B6847}", AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_TYPENAME)

	AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_POSTFIX_UUID (AZStd::vector, "AZStd::vector", "{A60E3E61-1FF6-4982-B6B8-9E4350C4C679}", AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_TYPENAME)

	AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_POSTFIX_UUID (AZStd::list, "AZStd::list", "{E1E05843-BB02-4F43-B7DC-3ADB28DF42AC}", AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_TYPENAME)

	AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_POSTFIX_UUID (AZStd::forward_list, "AZStd::forward_list", "{D7E91EA3-326F-4019-87F0-6F45924B909A}", AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_TYPENAME)

	AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_POSTFIX_UUID (AZStd::set, "AZStd::set", "{6C51837F-B0C9-40A3-8D52-2143341EDB07}", AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_TYPENAME)

	AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_POSTFIX_UUID (AZStd::unordered_set, "AZStd::unordered_set", "{8D60408E-DA65-4670-99A2-8ABB574625AE}", AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_TYPENAME)

	AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_POSTFIX_UUID (AZStd::unordered_multiset, "AZStd::unordered_multiset", "{B5950921-7F70-4806-9C13-8C7DF841BB90}", AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_TYPENAME)

	AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_POSTFIX_UUID (AZStd::map, "AZStd::map", "{F8ECF58D-D33E-49DC-BF34-8FA499AC3AE1}", AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_TYPENAME)

	AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_POSTFIX_UUID (AZStd::unordered_map, "AZStd::unordered_map", "{41171F6F-9E5E-4227-8420-289F1DD5D005}", AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_TYPENAME)

	AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_POSTFIX_UUID (AZStd::unordered_multimap, "AZStd::unordered_multimap", "{9ED846FA-31C1-4133-B4F4-91DF9750BA96}", AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_TYPENAME)

	AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_POSTFIX_UUID (AZStd::shared_ptr, "AZStd::shared_ptr", "{FE61C84E-149D-43FD-88BA-1C3DB7E548B4}", AZ_TYPE_INFO_INTERNAL_TYPENAME)

	AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_POSTFIX_UUID (AZStd::intrusive_ptr, "AZStd::intrusive_ptr", "{530F8502-309E-4EE1-9AEF-5C0456B1F502}", AZ_TYPE_INFO_INTERNAL_TYPENAME)

	AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_POSTFIX_UUID (AZStd::fixed_vector, "AZStd::fixed_vector", "{74044B6F-E922-4FD7-915D-EFC5D1DC59AE}", AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_AUTO)

	AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_POSTFIX_UUID (AZStd::fixed_list, "AZStd::fixed_list", "{508B9687-8410-4A73-AE0C-0BA15CF3F773}", AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_AUTO)

	AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_POSTFIX_UUID (AZStd::fixed_forward_list, "AZStd::fixed_forward_list", "{0D9D2AB2-F0CC-4E30-A209-A33D78717649}", AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_AUTO)

	AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_POSTFIX_UUID (AZStd::array, "AZStd::array", "{911B2EA8-CCB1-4F0C-A535-540AD00173AE}", AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_AUTO)

	AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_POSTFIX_UUID (AZStd::bitset, "AZStd::bitset", "{6BAE9836-EC49-466A-85F2-F4B1B70839FB}", AZ_TYPE_INFO_INTERNAL_AUTO)

	AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_PREFIX_UUID (AZStd::variant, "AZStd::variant", s_variantTypeId, AZ_TYPE_INFO_INTERNAL_TYPENAME_VARARGS)

	AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_PREFIX_UUID (AZStd::function, "AZStd::function", "{C9F9C644-CCC3-4F77-A792-F5B5DBCA746E}", AZ_TYPE_INFO_INTERNAL_TYPENAME)

	AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_BOTHFIX_UUID_DECL_API (AZCORE_API, AZStd::char_traits, AZ_TYPE_INFO_INTERNAL_TYPENAME)

	AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_BOTHFIX_UUID_DECL_API (AZCORE_API, AZStd::basic_string_view, AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_TYPENAME)

	AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_BOTHFIX_UUID_DECL_API (AZCORE_API, AZStd::basic_string, AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_TYPENAME)

	AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_BOTHFIX_UUID_DECL_API (AZCORE_API, AZStd::basic_fixed_string, AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_AUTO, AZ_TYPE_INFO_INTERNAL_TYPENAME)

constexpr AZ::TemplateId	GetO3deTemplateId (AZ::Adl, AZ::AzGenericTypeInfo::Internal::TemplateIdentityTypeAuto< AZStd::span >)

template<typename T1 >
AZ::TypeNameString	GetO3deTypeName (AZ::Adl, AZStd::type_identity< AZStd::span< T1 > >)

template<typename T1 >
AZ::TypeId	GetO3deTypeId (AZ::Adl, AZStd::type_identity< AZStd::span< T1 > >)

template<typename T1 >
AZ::TemplateId	GetO3deClassTemplateId (AZ::Adl, AZStd::type_identity< AZStd::span< T1 > >)

template<class T >
constexpr T	GetMin (const T &left, const T &right)

template<class T >
constexpr T min	AZ_PREVENT_MACRO_SUBSTITUTION (const T &left, const T &right)

template<class T >
constexpr T	GetMax (const T &left, const T &right)

template<class T >
constexpr T max	AZ_PREVENT_MACRO_SUBSTITUTION (const T &left, const T &right)

template<class T , class Compare >
constexpr pair< T, T > minmax	AZ_PREVENT_MACRO_SUBSTITUTION (const T &left, const T &right, Compare comp)

template<class T >
constexpr pair< T, T > minmax	AZ_PREVENT_MACRO_SUBSTITUTION (const T &left, const T &right)

template<class ForwardIt , class Compare >
constexpr pair< ForwardIt, ForwardIt >	minmax_element (ForwardIt first, ForwardIt last, Compare comp)

template<class ForwardIt >
constexpr pair< ForwardIt, ForwardIt >	minmax_element (ForwardIt first, ForwardIt last)

template<class T , class Compare >
constexpr pair< T, T > minmax	AZ_PREVENT_MACRO_SUBSTITUTION (std::initializer_list< T > ilist, Compare comp)

template<class T >
constexpr pair< T, T > minmax	AZ_PREVENT_MACRO_SUBSTITUTION (std::initializer_list< T > ilist)

template<class T >
constexpr T	clamp (const T &val, const T &lower, const T &upper)

template<class InputIterator1 , class InputIterator2 >
constexpr pair< InputIterator1, InputIterator2 >	mismatch (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2)

template<class InputIterator1 , class InputIterator2 , class BinaryPredicate >
constexpr pair< InputIterator1, InputIterator2 >	mismatch (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, BinaryPredicate binaryPredicate)

template<class InputIterator1 , class InputIterator2 >
constexpr pair< InputIterator1, InputIterator2 >	mismatch (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2)

template<class InputIterator1 , class InputIterator2 , class BinaryPredicate >
constexpr pair< InputIterator1, InputIterator2 >	mismatch (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, BinaryPredicate binaryPredicate)

template<class InputIterator1 , class InputIterator2 >
constexpr bool	equal (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2)

template<class InputIterator1 , class InputIterator2 , class BinaryPredicate >
constexpr bool	equal (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, BinaryPredicate binaryPredicate)

template<class InputIterator1 , class InputIterator2 >
constexpr bool	equal (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2)

template<class InputIterator1 , class InputIterator2 , class BinaryPredicate >
constexpr bool	equal (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, BinaryPredicate binaryPredicate)

template<class InputIter , class Function >
constexpr Function	for_each (InputIter first, InputIter last, Function f)

template<class InputIter , class Predicate >
constexpr iterator_traits< InputIter >::difference_type	count_if (InputIter first, InputIter last, Predicate pred)

template<class InputIterator , class ComparableToIteratorValue >
constexpr InputIterator	find (InputIterator first, InputIterator last, const ComparableToIteratorValue &value)

template<class InputIterator , class Predicate >
constexpr InputIterator	find_if (InputIterator first, InputIterator last, Predicate pred)

template<class InputIterator , class Predicate >
constexpr InputIterator	find_if_not (InputIterator first, InputIterator last, Predicate pred)

template<class ForwardIter , class BinaryPredicate >
constexpr ForwardIter	adjacent_find (ForwardIter first, ForwardIter last, BinaryPredicate binary_pred)

template<class ForwardIter >
constexpr ForwardIter	adjacent_find (ForwardIter first, ForwardIter last)

template<class InputIter , class ForwardIter , class BinaryPredicate >
constexpr InputIter	find_first_of (InputIter first1, InputIter last1, ForwardIter first2, ForwardIter last2, BinaryPredicate comp)

template<class InputIter , class ForwardIter >
constexpr InputIter	find_first_of (InputIter first1, InputIter last1, ForwardIter first2, ForwardIter last2)

template<class InputIter , class UnaryOperation >
constexpr bool	all_of (InputIter first, InputIter last, UnaryOperation operation)

template<class InputIter , class UnaryOperation >
constexpr bool	any_of (InputIter first, InputIter last, UnaryOperation operation)

template<class InputIter , class UnaryOperation >
constexpr bool	none_of (InputIter first, InputIter last, UnaryOperation operation)

template<class InputIterator , class OutputIterator , class UnaryOperation >
constexpr OutputIterator	transform (InputIterator first, InputIterator last, OutputIterator result, UnaryOperation operation)

template<class InputIterator1 , class InputIterator2 , class OutputIterator , class BinaryOperation >
constexpr OutputIterator	transform (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator result, BinaryOperation operation)

template<class ForwardIter , class T >
constexpr void	replace (ForwardIter first, ForwardIter last, const T &old_value, const T &new_value)

template<class ForwardIter , class Predicate , class T >
constexpr void	replace_if (ForwardIter first, ForwardIter last, Predicate pred, const T &new_value)

template<class InputIter , class OutputIter , class T >
constexpr OutputIter	replace_copy (InputIter first, InputIter last, OutputIter result, const T &old_value, const T &new_value)

template<class Iterator , class OutputIter , class Predicate , class T >
constexpr OutputIter	replace_copy_if (Iterator first, Iterator last, OutputIter result, Predicate pred, const T &new_value)

template<class ForwardIter , class Generator >
constexpr void	generate (ForwardIter first, ForwardIter last, Generator gen)

template<class OutputIter , class Size , class Generator >
constexpr void	generate_n (OutputIter first, Size n, Generator gen)

template<class InputIter , class OutputIter , class T >
constexpr OutputIter	remove_copy (InputIter first, InputIter last, OutputIter result, const T &val)

template<class InputIter , class OutputIter , class Predicate >
constexpr OutputIter	remove_copy_if (InputIter first, InputIter last, OutputIter result, Predicate pred)

template<class ForwardIter , class T >
constexpr ForwardIter	remove (ForwardIter first, ForwardIter last, const T &val)

template<class ForwardIter , class Predicate >
constexpr ForwardIter	remove_if (ForwardIter first, ForwardIter last, Predicate pred)

template<class RandomAccessIterator >
constexpr void	push_heap (RandomAccessIterator first, RandomAccessIterator last)
	Pushes values to the heap using AZStd::less predicate. CStd.

template<class RandomAccessIterator , class Compare >
constexpr void	push_heap (RandomAccessIterator first, RandomAccessIterator last, Compare comp)
	Pushes values to the heap using provided binary predicate Compare. CStd.

template<class RandomAccessIterator >
constexpr void	pop_heap (RandomAccessIterator first, RandomAccessIterator last)
	Prepares heap for popping a value using AZStd::less predicate. CStd.

template<class RandomAccessIterator , class Compare >
constexpr void	pop_heap (RandomAccessIterator first, RandomAccessIterator last, Compare comp)
	Prepares heap for popping a value using Compare predicate. CStd.

template<class RandomAccessIterator >
constexpr void	pop_heap (RandomAccessIterator first, RandomAccessIterator last, RandomAccessIterator result)
	[Extension] Same as AZStd::pop_heap using AZStd::less predicate, but allows you to provide iterator where to store the result.

template<class RandomAccessIterator , class Compare >
constexpr void	pop_heap (RandomAccessIterator first, RandomAccessIterator last, RandomAccessIterator result, Compare comp)
	[Extension] Same as AZStd::pop_heap using Compare predicate, but allows you to provide iterator where to store the result.

template<class RandomAccessIterator >
constexpr void	make_heap (RandomAccessIterator first, RandomAccessIterator last)
	Make a heap from an array of values, using AZStd::less predicate. CStd.

template<class RandomAccessIterator , class Compare >
constexpr void	make_heap (RandomAccessIterator first, RandomAccessIterator last, Compare comp)
	Make a heap from an array of values, using Compare predicate. CStd.

template<class RandomAccessIterator >
constexpr void	sort_heap (RandomAccessIterator first, RandomAccessIterator last)
	Preforms a heap sort on a range of values, using AZStd::less predicate. CStd.

template<class RandomAccessIterator , class Compare >
constexpr void	sort_heap (RandomAccessIterator first, RandomAccessIterator last, Compare comp)
	Preforms a heap sort on a range of values, using Compare predicate. CStd.

template<class ForwardIterator , class T >
constexpr ForwardIterator	lower_bound (ForwardIterator first, ForwardIterator last, const T &value)

template<class ForwardIterator , class T , class Compare >
constexpr ForwardIterator	lower_bound (ForwardIterator first, ForwardIterator last, const T &value, Compare comp)

template<class ForwardIterator , class T >
constexpr ForwardIterator	upper_bound (ForwardIterator first, ForwardIterator last, const T &value)

template<class ForwardIterator , class T , class Compare >
constexpr ForwardIterator	upper_bound (ForwardIterator first, ForwardIterator last, const T &value, Compare comp)

template<class ForwardIterator1 , class ForwardIterator2 >
constexpr ForwardIterator1	search (ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2)

template<class ForwardIterator1 , class ForwardIterator2 , class Compare >
constexpr ForwardIterator1	search (ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, Compare comp)

template<class ForwardIterator >
constexpr bool	is_sorted (ForwardIterator first, ForwardIterator last)

template<class ForwardIterator , class Compare >
constexpr bool	is_sorted (ForwardIterator first, ForwardIterator last, Compare comp)

template<class ForwardIterator >
constexpr ForwardIterator	unique (ForwardIterator first, ForwardIterator last)

template<class ForwardIterator , class BinaryPredicate >
constexpr ForwardIterator	unique (ForwardIterator first, ForwardIterator last, BinaryPredicate pred)

template<class Compare , class InputIterator1 , class InputIterator2 , class OutputIterator >
constexpr OutputIterator	set_difference (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp)

template<class InputIterator1 , class InputIterator2 , class OutputIterator >
constexpr OutputIterator	set_difference (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result)

template<class InputIterator1 , class InputIterator2 >
constexpr bool	lexicographical_compare (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2)

constexpr bool	lexicographical_compare (const unsigned char first1, const unsigned char last1, const unsigned char first2, const unsigned char last2)

template<class InputIterator1 , class InputIterator2 , class Compare >
constexpr bool	lexicographical_compare (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, Compare comp)

template<typename T >
AZ_FORCE_INLINE void	endian_swap (T &data)

template<typename Iterator >
AZ_FORCE_INLINE void	endian_swap (Iterator first, Iterator last)

AZ_FORCE_INLINE bool	operator== (const AZStd::allocator &a, const AZStd::allocator &b)

AZ_FORCE_INLINE bool	operator!= (const AZStd::allocator &a, const AZStd::allocator &b)

template<class Allocator >
AZ_FORCE_INLINE bool	operator== (const AZStd::allocator_ref< Allocator > &a, const AZStd::allocator_ref< Allocator > &b)

template<class Allocator >
AZ_FORCE_INLINE bool	operator!= (const AZStd::allocator_ref< Allocator > &a, const AZStd::allocator_ref< Allocator > &b)

AZ_FORCE_INLINE bool	operator== (const stack_allocator &a, const stack_allocator &b)

AZ_FORCE_INLINE bool	operator!= (const stack_allocator &a, const stack_allocator &b)

AZCORE_API bool	operator== (const stateless_allocator &left, const stateless_allocator &right)

AZCORE_API bool	operator!= (const stateless_allocator &left, const stateless_allocator &right)

template<AZStd::size_t Size, AZStd::size_t Alignment>
AZ_FORCE_INLINE bool	operator== (const static_buffer_allocator< Size, Alignment > &a, const static_buffer_allocator< Size, Alignment > &b)

template<AZStd::size_t Size, AZStd::size_t Alignment>
AZ_FORCE_INLINE bool	operator!= (const static_buffer_allocator< Size, Alignment > &a, const static_buffer_allocator< Size, Alignment > &b)

template<class Node , AZStd::size_t NumNodes>
AZ_FORCE_INLINE bool	operator== (const static_pool_allocator< Node, NumNodes > &a, const static_pool_allocator< Node, NumNodes > &b)

template<class Node , AZStd::size_t NumNodes>
AZ_FORCE_INLINE bool	operator!= (const static_pool_allocator< Node, NumNodes > &a, const static_pool_allocator< Node, NumNodes > &b)

template<typename ValueType >
ValueType	any_cast (const any &operand)

template<typename ValueType >
ValueType	any_cast (any &operand)

template<typename ValueType >
ValueType	any_cast (any &&operand)

template<typename ValueType >
add_pointer_t< add_const_t< ValueType > >	any_cast (const any *operand)

template<typename ValueType >
add_pointer_t< ValueType >	any_cast (any *operand)

template<>
void *	any_cast< void > (any *operand)

template<typename ValueType , typename = enable_if_t<std::numeric_limits<ValueType>::is_specialized>>
bool	any_numeric_cast (const any *operand, ValueType &result)

template<typename ValueType , typename... Args>
any	make_any (Args &&... args)

template<typename ValueType , typename U , typename... Args>
any	make_any (AZStd::initializer_list< U > il, Args &&... args)

template<class T , class... U>
	array (T, U...) -> array< T, 1+sizeof...(U)>

template<class T , size_t N>
bool	operator== (const array< T, N > &a, const array< T, N > &b)

template<class T , size_t N>
bool	operator!= (const array< T, N > &a, const array< T, N > &b)

template<class T , size_t N>
constexpr array< remove_cv_t< T >, N >	to_array (T(&arr)[N])

template<class T , size_t N>
constexpr array< remove_cv_t< T >, N >	to_array (T(&&arr)[N])

template<size_t I, class T , size_t N>
constexpr T &	get (array< T, N > &arr)

template<size_t I, class T , size_t N>
constexpr const T &	get (const array< T, N > &arr)

template<size_t I, class T , size_t N>
constexpr T &&	get (array< T, N > &&arr)

template<size_t I, class T , size_t N>
constexpr const T &&	get (const array< T, N > &&arr)

template<AZStd::size_t NumBits>
bitset< NumBits >	operator& (const bitset< NumBits > &left, const bitset< NumBits > &right)

template<AZStd::size_t NumBits>
bitset< NumBits >	operator\| (const bitset< NumBits > &left, const bitset< NumBits > &right)

template<AZStd::size_t NumBits>
bitset< NumBits >	operator^ (const bitset< NumBits > &left, const bitset< NumBits > &right)

template<class T1 , class T2 >
void	swap (compressed_pair< T1, T2 > &lhs, compressed_pair< T1, T2 > &rhs)

template<class InputIt , class Alloc = allocator>
	deque (InputIt, InputIt, Alloc=Alloc()) -> deque< iter_value_t< InputIt >, Alloc >

template<class R , class Alloc = allocator, class = enable_if_t<ranges::input_range<R>>>
	deque (from_range_t, R &&, Alloc=Alloc()) -> deque< ranges::range_value_t< R >, Alloc >

template<class T , class Allocator , AZStd::size_t NumElementsPerBlock, AZStd::size_t MinMapSize>
AZ_FORCE_INLINE bool	operator== (const deque< T, Allocator, NumElementsPerBlock, MinMapSize > &left, const deque< T, Allocator, NumElementsPerBlock, MinMapSize > &right)

template<class T , class Allocator , AZStd::size_t NumElementsPerBlock, AZStd::size_t MinMapSize>
AZ_FORCE_INLINE bool	operator!= (const deque< T, Allocator, NumElementsPerBlock, MinMapSize > &left, const deque< T, Allocator, NumElementsPerBlock, MinMapSize > &right)

template<class T , class Allocator , AZStd::size_t NumElementsPerBlock, AZStd::size_t MinMapSize>
AZ_FORCE_INLINE void	swap (deque< T, Allocator, NumElementsPerBlock, MinMapSize > &left, deque< T, Allocator, NumElementsPerBlock, MinMapSize > &right)

template<class T , class Allocator , AZStd::size_t NumElementsPerBlock, AZStd::size_t MinMapSize, class U >
decltype(auto)	erase (deque< T, Allocator, NumElementsPerBlock, MinMapSize > &container, const U &value)

template<class T , class Allocator , AZStd::size_t NumElementsPerBlock, AZStd::size_t MinMapSize, class Predicate >
decltype(auto)	erase_if (deque< T, Allocator, NumElementsPerBlock, MinMapSize > &container, Predicate predicate)

template<class T , AZStd::size_t NumberOfNodes>
AZ_FORCE_INLINE bool	operator== (const fixed_list< T, NumberOfNodes > &left, const fixed_list< T, NumberOfNodes > &right)

template<class T , AZStd::size_t NumberOfNodes>
AZ_FORCE_INLINE bool	operator!= (const fixed_list< T, NumberOfNodes > &left, const fixed_list< T, NumberOfNodes > &right)

template<class Key , class MappedType , AZStd::size_t FixedNumBuckets, AZStd::size_t FixedNumElements, class Hasher , class EqualKey >
AZ_FORCE_INLINE void	swap (fixed_unordered_map< Key, MappedType, FixedNumBuckets, FixedNumElements, Hasher, EqualKey > &left, fixed_unordered_map< Key, MappedType, FixedNumBuckets, FixedNumElements, Hasher, EqualKey > &right)

template<class Key , class MappedType , AZStd::size_t FixedNumBuckets, AZStd::size_t FixedNumElements, class Hasher , class EqualKey >
AZ_FORCE_INLINE void	swap (fixed_unordered_multimap< Key, MappedType, FixedNumBuckets, FixedNumElements, Hasher, EqualKey > &left, fixed_unordered_multimap< Key, MappedType, FixedNumBuckets, FixedNumElements, Hasher, EqualKey > &right)

template<class Key , AZStd::size_t FixedNumBuckets, AZStd::size_t FixedNumElements, class Hasher , class EqualKey >
AZ_FORCE_INLINE void	swap (fixed_unordered_set< Key, FixedNumBuckets, FixedNumElements, Hasher, EqualKey > &left, fixed_unordered_set< Key, FixedNumBuckets, FixedNumElements, Hasher, EqualKey > &right)

template<class Key , AZStd::size_t FixedNumBuckets, AZStd::size_t FixedNumElements, class Hasher , class EqualKey >
AZ_FORCE_INLINE void	swap (fixed_unordered_multiset< Key, FixedNumBuckets, FixedNumElements, Hasher, EqualKey > &left, fixed_unordered_multiset< Key, FixedNumBuckets, FixedNumElements, Hasher, EqualKey > &right)

template<class T , class... U>
	fixed_vector (T, U...) -> fixed_vector< T, 1+sizeof...(U)>
	Deduction Guide for AZStd::fixed_vector.

template<class T , AZStd::size_t Capacity1, AZStd::size_t Capacity2>
constexpr bool	operator== (const fixed_vector< T, Capacity1 > &a, const fixed_vector< T, Capacity2 > &b)

template<class T , AZStd::size_t Capacity1, AZStd::size_t Capacity2>
constexpr bool	operator!= (const fixed_vector< T, Capacity1 > &a, const fixed_vector< T, Capacity2 > &b)

template<class T , AZStd::size_t Capacity1, AZStd::size_t Capacity2>
constexpr bool	operator< (const fixed_vector< T, Capacity1 > &a, const fixed_vector< T, Capacity2 > &b)

template<class T , AZStd::size_t Capacity1, AZStd::size_t Capacity2>
constexpr bool	operator<= (const fixed_vector< T, Capacity1 > &a, const fixed_vector< T, Capacity2 > &b)

template<class T , AZStd::size_t Capacity1, AZStd::size_t Capacity2>
constexpr bool	operator> (const fixed_vector< T, Capacity1 > &a, const fixed_vector< T, Capacity2 > &b)

template<class T , AZStd::size_t Capacity1, AZStd::size_t Capacity2>
constexpr bool	operator>= (const fixed_vector< T, Capacity1 > &a, const fixed_vector< T, Capacity2 > &b)

template<class T , size_t Capacity, class U >
constexpr decltype(auto)	erase (fixed_vector< T, Capacity > &container, const U &value)

template<class T , size_t Capacity, class Predicate >
constexpr decltype(auto)	erase_if (fixed_vector< T, Capacity > &container, Predicate predicate)

template<class InputIt , class Alloc = allocator>
	forward_list (InputIt, InputIt, Alloc=Alloc{}) -> forward_list< iter_value_t< InputIt >, Alloc >

template<class R , class Alloc = allocator, class = enable_if_t<ranges::input_range<R>>>
	forward_list (from_range_t, R &&, Alloc=Alloc{}) -> forward_list< ranges::range_value_t< R >, Alloc >

template<class T , class Allocator , class U >
decltype(auto)	erase (forward_list< T, Allocator > &container, const U &value)

template<class T , class Allocator , class Predicate >
decltype(auto)	erase_if (forward_list< T, Allocator > &container, Predicate predicate)

template<class T , class Hook >
AZ_FORCE_INLINE bool	operator== (const intrusive_list< T, Hook > &left, const intrusive_list< T, Hook > &right)

template<class T , class Hook >
AZ_FORCE_INLINE bool	operator!= (const intrusive_list< T, Hook > &left, const intrusive_list< T, Hook > &right)

template<class T , class Hook , class Compare >
AZ_FORCE_INLINE bool	operator== (const intrusive_multiset< T, Hook, Compare > &left, const intrusive_multiset< T, Hook, Compare > &right)

template<class T , class Hook , class Compare >
AZ_FORCE_INLINE bool	operator!= (const intrusive_multiset< T, Hook, Compare > &left, const intrusive_multiset< T, Hook, Compare > &right)

template<class T , class Hook >
AZ_FORCE_INLINE bool	operator== (const intrusive_slist< T, Hook > &left, const intrusive_slist< T, Hook > &right)

template<class T , class Hook >
AZ_FORCE_INLINE bool	operator!= (const intrusive_slist< T, Hook > &left, const intrusive_slist< T, Hook > &right)

template<class InputIt , class Alloc = allocator>
	list (InputIt, InputIt, Alloc=Alloc()) -> list< iter_value_t< InputIt >, Alloc >

template<class R , class Alloc = allocator, class = enable_if_t<ranges::input_range<R>>>
	list (from_range_t, R &&, Alloc=Alloc()) -> list< ranges::range_value_t< R >, Alloc >

template<class T , class Allocator >
AZ_FORCE_INLINE bool	operator== (const list< T, Allocator > &left, const list< T, Allocator > &right)

template<class T , class Allocator >
AZ_FORCE_INLINE bool	operator!= (const list< T, Allocator > &left, const list< T, Allocator > &right)

template<class T , class Allocator , class U >
decltype(auto)	erase (list< T, Allocator > &container, const U &value)

template<class T , class Allocator , class Predicate >
decltype(auto)	erase_if (list< T, Allocator > &container, Predicate predicate)

template<class Key , class MappedType , class Compare , class Allocator >
AZ_FORCE_INLINE void	swap (map< Key, MappedType, Compare, Allocator > &left, map< Key, MappedType, Compare, Allocator > &right)

template<class Key , class MappedType , class Compare , class Allocator >
bool	operator== (const map< Key, MappedType, Compare, Allocator > &left, const map< Key, MappedType, Compare, Allocator > &right)

template<class Key , class MappedType , class Compare , class Allocator >
bool	operator!= (const map< Key, MappedType, Compare, Allocator > &left, const map< Key, MappedType, Compare, Allocator > &right)

template<class Key , class MappedType , class Compare , class Allocator >
bool	operator< (const map< Key, MappedType, Compare, Allocator > &left, const map< Key, MappedType, Compare, Allocator > &right)

template<class Key , class MappedType , class Compare , class Allocator >
bool	operator> (const map< Key, MappedType, Compare, Allocator > &left, const map< Key, MappedType, Compare, Allocator > &right)

template<class Key , class MappedType , class Compare , class Allocator >
bool	operator<= (const map< Key, MappedType, Compare, Allocator > &left, const map< Key, MappedType, Compare, Allocator > &right)

template<class Key , class MappedType , class Compare , class Allocator >
bool	operator>= (const map< Key, MappedType, Compare, Allocator > &left, const map< Key, MappedType, Compare, Allocator > &right)

template<class Key , class MappedType , class Compare , class Allocator , class Predicate >
decltype(auto)	erase_if (map< Key, MappedType, Compare, Allocator > &container, Predicate predicate)

template<class InputIterator , class Compare = less<iter_key_type<InputIterator>>, class Allocator = allocator>
	map (InputIterator, InputIterator, Compare=Compare(), Allocator=Allocator()) -> map< iter_key_type< InputIterator >, iter_mapped_type< InputIterator >, Compare, Allocator >

template<class R , class Compare = less<range_key_type<R>>, class Allocator = allocator, class = enable_if_t<ranges::input_range<R>>>
	map (from_range_t, R &&, Compare=Compare(), Allocator=Allocator()) -> map< range_key_type< R >, range_mapped_type< R >, Compare, Allocator >

template<class Key , class T , class Compare = less<Key>, class Allocator = allocator>
	map (initializer_list< pair< Key, T > >, Compare=Compare(), Allocator=Allocator()) -> map< Key, T, Compare, Allocator >

template<class InputIterator , class Allocator >
	map (InputIterator, InputIterator, Allocator) -> map< iter_key_type< InputIterator >, iter_mapped_type< InputIterator >, less< iter_key_type< InputIterator > >, Allocator >

template<class R , class Allocator , class = enable_if_t<ranges::input_range<R>>>
	map (from_range_t, R &&, Allocator) -> map< range_key_type< R >, range_mapped_type< R >, less< range_key_type< R > >, Allocator >

template<class Key , class T , class Allocator >
	map (initializer_list< pair< Key, T > >, Allocator) -> map< Key, T, less< Key >, Allocator >

template<class Key , class MappedType , class Compare , class Allocator >
AZ_FORCE_INLINE void	swap (multimap< Key, MappedType, Compare, Allocator > &left, multimap< Key, MappedType, Compare, Allocator > &right)

template<class Key , class MappedType , class Compare , class Allocator >
bool	operator== (const multimap< Key, MappedType, Compare, Allocator > &left, const multimap< Key, MappedType, Compare, Allocator > &right)

template<class Key , class MappedType , class Compare , class Allocator >
bool	operator!= (const multimap< Key, MappedType, Compare, Allocator > &left, const multimap< Key, MappedType, Compare, Allocator > &right)

template<class Key , class MappedType , class Compare , class Allocator >
bool	operator< (const multimap< Key, MappedType, Compare, Allocator > &left, const multimap< Key, MappedType, Compare, Allocator > &right)

template<class Key , class MappedType , class Compare , class Allocator >
bool	operator> (const multimap< Key, MappedType, Compare, Allocator > &left, const multimap< Key, MappedType, Compare, Allocator > &right)

template<class Key , class MappedType , class Compare , class Allocator >
bool	operator<= (const multimap< Key, MappedType, Compare, Allocator > &left, const multimap< Key, MappedType, Compare, Allocator > &right)

template<class Key , class MappedType , class Compare , class Allocator >
bool	operator>= (const multimap< Key, MappedType, Compare, Allocator > &left, const multimap< Key, MappedType, Compare, Allocator > &right)

template<class Key , class MappedType , class Compare , class Allocator , class Predicate >
decltype(auto)	erase_if (multimap< Key, MappedType, Compare, Allocator > &container, Predicate predicate)

template<class InputIterator , class Compare = less<iter_key_type<InputIterator>>, class Allocator = allocator>
	multimap (InputIterator, InputIterator, Compare=Compare(), Allocator=Allocator()) -> multimap< iter_key_type< InputIterator >, iter_mapped_type< InputIterator >, Compare, Allocator >

template<class R , class Compare = less<range_key_type<R>>, class Allocator = allocator, class = enable_if_t<ranges::input_range<R>>>
	multimap (from_range_t, R &&, Compare=Compare(), Allocator=Allocator()) -> multimap< range_key_type< R >, range_mapped_type< R >, Compare, Allocator >

template<class Key , class T , class Compare = less<Key>, class Allocator = allocator>
	multimap (initializer_list< pair< Key, T > >, Compare=Compare(), Allocator=Allocator()) -> multimap< Key, T, Compare, Allocator >

template<class InputIterator , class Allocator >
	multimap (InputIterator, InputIterator, Allocator) -> multimap< iter_key_type< InputIterator >, iter_mapped_type< InputIterator >, less< iter_key_type< InputIterator > >, Allocator >

template<class R , class Allocator , class = enable_if_t<ranges::input_range<R>>>
	multimap (from_range_t, R &&, Allocator) -> multimap< range_key_type< R >, range_mapped_type< R >, less< range_key_type< R > >, Allocator >

template<class Key , class T , class Allocator >
	multimap (initializer_list< pair< Key, T > >, Allocator) -> multimap< Key, T, less< Key >, Allocator >

template<class T , class Allocator >
bool	operator== (const ring_buffer< T, Allocator > &lhs, const ring_buffer< T, Allocator > &rhs)

template<class T , class Allocator >
bool	operator!= (const ring_buffer< T, Allocator > &lhs, const ring_buffer< T, Allocator > &rhs)

template<class T , class Allocator >
AZ_FORCE_INLINE void	swap (ring_buffer< T, Allocator > &lhs, ring_buffer< T, Allocator > &rhs)

template<class Key , class Compare , class Allocator >
AZ_FORCE_INLINE void	swap (set< Key, Compare, Allocator > &left, set< Key, Compare, Allocator > &right)

template<class Key , class Compare , class Allocator >
bool	operator== (const set< Key, Compare, Allocator > &left, const set< Key, Compare, Allocator > &right)

template<class Key , class Compare , class Allocator >
bool	operator!= (const set< Key, Compare, Allocator > &left, const set< Key, Compare, Allocator > &right)

template<class Key , class Compare , class Allocator >
bool	operator< (const set< Key, Compare, Allocator > &left, const set< Key, Compare, Allocator > &right)

template<class Key , class Compare , class Allocator >
bool	operator> (const set< Key, Compare, Allocator > &left, const set< Key, Compare, Allocator > &right)

template<class Key , class Compare , class Allocator >
bool	operator<= (const set< Key, Compare, Allocator > &left, const set< Key, Compare, Allocator > &right)

template<class Key , class Compare , class Allocator >
bool	operator>= (const set< Key, Compare, Allocator > &left, const set< Key, Compare, Allocator > &right)

template<class Key , class Compare , class Allocator , class Predicate >
decltype(auto)	erase_if (set< Key, Compare, Allocator > &container, Predicate predicate)

template<class InputIterator , class Compare = less<iter_value_type<InputIterator>>, class Allocator = allocator>
	set (InputIterator, InputIterator, Compare=Compare(), Allocator=Allocator()) -> set< iter_value_type< InputIterator >, Compare, Allocator >

template<class R , class Compare = less<ranges::range_value_t<R>>, class Allocator = allocator, class = enable_if_t<ranges::input_range<R>>>
	set (from_range_t, R &&, Compare=Compare(), Allocator=Allocator()) -> set< ranges::range_value_t< R >, Compare, Allocator >

template<class Key , class Compare = less<Key>, class Allocator = allocator>
	set (initializer_list< Key >, Compare=Compare(), Allocator=Allocator()) -> set< Key, Compare, Allocator >

template<class InputIterator , class Allocator >
	set (InputIterator, InputIterator, Allocator) -> set< iter_value_type< InputIterator >, less< iter_value_type< InputIterator > >, Allocator >

template<class R , class Allocator , class = enable_if_t<ranges::input_range<R>>>
	set (from_range_t, R &&, Allocator) -> set< ranges::range_value_t< R >, less< ranges::range_value_t< R > >, Allocator >

template<class Key , class Allocator >
	set (initializer_list< Key >, Allocator) -> set< Key, less< Key >, Allocator >

template<class Key , class Compare , class Allocator >
AZ_FORCE_INLINE void	swap (multiset< Key, Compare, Allocator > &left, multiset< Key, Compare, Allocator > &right)

template<class Key , class Compare , class Allocator >
bool	operator== (const multiset< Key, Compare, Allocator > &left, const multiset< Key, Compare, Allocator > &right)

template<class Key , class Compare , class Allocator >
bool	operator!= (const multiset< Key, Compare, Allocator > &left, const multiset< Key, Compare, Allocator > &right)

template<class Key , class Compare , class Allocator >
bool	operator< (const multiset< Key, Compare, Allocator > &left, const multiset< Key, Compare, Allocator > &right)

template<class Key , class Compare , class Allocator >
bool	operator> (const multiset< Key, Compare, Allocator > &left, const multiset< Key, Compare, Allocator > &right)

template<class Key , class Compare , class Allocator >
bool	operator<= (const multiset< Key, Compare, Allocator > &left, const multiset< Key, Compare, Allocator > &right)

template<class Key , class Compare , class Allocator >
bool	operator>= (const multiset< Key, Compare, Allocator > &left, const multiset< Key, Compare, Allocator > &right)

template<class Key , class Compare , class Allocator , class Predicate >
decltype(auto)	erase_if (multiset< Key, Compare, Allocator > &container, Predicate predicate)

template<class InputIterator , class Compare = less<iter_value_type<InputIterator>>, class Allocator = allocator>
	multiset (InputIterator, InputIterator, Compare=Compare(), Allocator=Allocator()) -> multiset< iter_value_type< InputIterator >, Compare, Allocator >

template<class R , class Compare = less<ranges::range_value_t<R>>, class Allocator = allocator, class = enable_if_t<ranges::input_range<R>>>
	multiset (from_range_t, R &&, Compare=Compare(), Allocator=Allocator()) -> multiset< ranges::range_value_t< R >, Compare, Allocator >

template<class Key , class Compare = less<Key>, class Allocator = allocator>
	multiset (initializer_list< Key >, Compare=Compare(), Allocator=Allocator()) -> multiset< Key, Compare, Allocator >

template<class InputIterator , class Allocator >
	multiset (InputIterator, InputIterator, Allocator) -> multiset< iter_value_type< InputIterator >, less< iter_value_type< InputIterator > >, Allocator >

template<class R , class Allocator , class = enable_if_t<ranges::input_range<R>>>
	multiset (from_range_t, R &&, Allocator) -> multiset< ranges::range_value_t< R >, less< ranges::range_value_t< R > >, Allocator >

template<class Key , class Allocator >
	multiset (initializer_list< Key >, Allocator) -> multiset< Key, less< Key >, Allocator >

template<class It , class EndOrSize , class = enable_if_t<contiguous_iterator<It>>>
	span (It, EndOrSize) -> span< remove_reference_t< iter_reference_t< It > > >

template<class T , size_t N>
	span (T(&)[N]) -> span< T, N >

template<class T , size_t N>
	span (array< T, N > &) -> span< T, N >

template<class T , size_t N>
	span (const array< T, N > &) -> span< const T, N >

template<class R , class = enable_if_t<ranges::contiguous_range<R>>>
	span (R &&) -> span< remove_reference_t< ranges::range_reference_t< R > > >

template<class ElementType , size_t Extent>
auto	as_bytes (span< ElementType, Extent > s) noexcept -> span< const AZStd::byte, Extent==dynamic_extent ? dynamic_extent :sizeof(ElementType) *Extent >

template<class ElementType , size_t Extent>
auto	as_writable_bytes (span< ElementType, Extent > s) noexcept -> enable_if_t<!is_const_v< ElementType >, span< AZStd::byte, Extent==dynamic_extent ? dynamic_extent :sizeof(ElementType) *Extent > >

template<class Key , class MappedType , class Hasher , class EqualKey , class Allocator >
AZ_FORCE_INLINE void	swap (unordered_map< Key, MappedType, Hasher, EqualKey, Allocator > &left, unordered_map< Key, MappedType, Hasher, EqualKey, Allocator > &right)

template<class Key , class MappedType , class Hasher , class EqualKey , class Allocator >
AZ_FORCE_INLINE bool	operator== (const unordered_map< Key, MappedType, Hasher, EqualKey, Allocator > &a, const unordered_map< Key, MappedType, Hasher, EqualKey, Allocator > &b)

template<class Key , class MappedType , class Hasher , class EqualKey , class Allocator >
AZ_FORCE_INLINE bool	operator!= (const unordered_map< Key, MappedType, Hasher, EqualKey, Allocator > &a, const unordered_map< Key, MappedType, Hasher, EqualKey, Allocator > &b)

template<class Key , class MappedType , class Hasher , class EqualKey , class Allocator , class Predicate >
decltype(auto)	erase_if (unordered_map< Key, MappedType, Hasher, EqualKey, Allocator > &container, Predicate predicate)

template<class InputIterator , class Hash = hash<iter_key_type<InputIterator>>, class Pred = equal_to<iter_key_type<InputIterator>>, class Allocator = allocator>
	unordered_map (InputIterator, InputIterator, typename allocator_traits< Allocator >::size_type={}, Hash=Hash(), Pred=Pred(), Allocator=Allocator()) -> unordered_map< iter_key_type< InputIterator >, iter_mapped_type< InputIterator >, Hash, Pred, Allocator >

template<class R , class Hash = hash<range_key_type<R>>, class Pred = equal_to<range_key_type<R>>, class Allocator = allocator, class = enable_if_t<ranges::input_range<R>>>
	unordered_map (from_range_t, R &&, typename allocator_traits< Allocator >::size_type={}, Hash=Hash(), Pred=Pred(), Allocator=Allocator()) -> unordered_map< range_key_type< R >, range_mapped_type< R >, Hash, Pred, Allocator >

template<class Key , class T , class Hash = hash<Key>, class Pred = equal_to<Key>, class Allocator = allocator>
	unordered_map (initializer_list< pair< Key, T > >, typename allocator_traits< Allocator >::size_type={}, Hash=Hash(), Pred=Pred(), Allocator=Allocator()) -> unordered_map< Key, T, Hash, Pred, Allocator >

template<class InputIterator , class Allocator >
	unordered_map (InputIterator, InputIterator, typename allocator_traits< Allocator >::size_type, Allocator) -> unordered_map< iter_key_type< InputIterator >, iter_mapped_type< InputIterator >, hash< iter_key_type< InputIterator > >, equal_to< iter_key_type< InputIterator > >, Allocator >

template<class InputIterator , class Allocator >
	unordered_map (InputIterator, InputIterator, Allocator) -> unordered_map< iter_key_type< InputIterator >, iter_mapped_type< InputIterator >, hash< iter_key_type< InputIterator > >, equal_to< iter_key_type< InputIterator > >, Allocator >

template<class InputIterator , class Hash , class Allocator >
	unordered_map (InputIterator, InputIterator, typename allocator_traits< Allocator >::size_type, Hash, Allocator) -> unordered_map< iter_key_type< InputIterator >, iter_mapped_type< InputIterator >, Hash, equal_to< iter_key_type< InputIterator > >, Allocator >

template<class R , class Allocator = allocator, class = enable_if_t<ranges::input_range<R>>>
	unordered_map (from_range_t, R &&, typename allocator_traits< Allocator >::size_type, Allocator) -> unordered_map< range_key_type< R >, range_mapped_type< R >, hash< range_key_type< R > >, equal_to< range_key_type< R > >, Allocator >

template<class R , class Allocator = allocator, class = enable_if_t<ranges::input_range<R>>>
	unordered_map (from_range_t, R &&, Allocator) -> unordered_map< range_key_type< R >, range_mapped_type< R >, hash< range_key_type< R > >, equal_to< range_key_type< R > >, Allocator >

template<class R , class Hash , class Allocator , class = enable_if_t<ranges::input_range<R>>>
	unordered_map (from_range_t, R &&, typename allocator_traits< Allocator >::size_type, Hash, Allocator=Allocator()) -> unordered_map< range_key_type< R >, range_mapped_type< R >, Hash, equal_to< range_key_type< R > >, Allocator >

template<class Key , class T , class Allocator >
	unordered_map (initializer_list< pair< Key, T > >, typename allocator_traits< Allocator >::size_type, Allocator) -> unordered_map< Key, T, hash< Key >, equal_to< Key >, Allocator >

template<class Key , class T , class Allocator >
	unordered_map (initializer_list< pair< Key, T > >, Allocator) -> unordered_map< Key, T, hash< Key >, equal_to< Key >, Allocator >

template<class Key , class T , class Hash , class Allocator >
	unordered_map (initializer_list< pair< Key, T > >, typename allocator_traits< Allocator >::size_type, Hash, Allocator) -> unordered_map< Key, T, Hash, equal_to< Key >, Allocator >

template<class Key , class MappedType , class Hasher , class EqualKey , class Allocator >
AZ_FORCE_INLINE void	swap (unordered_multimap< Key, MappedType, Hasher, EqualKey, Allocator > &left, unordered_multimap< Key, MappedType, Hasher, EqualKey, Allocator > &right)

template<class Key , class MappedType , class Hasher , class EqualKey , class Allocator >
AZ_FORCE_INLINE bool	operator== (const unordered_multimap< Key, MappedType, Hasher, EqualKey, Allocator > &a, const unordered_multimap< Key, MappedType, Hasher, EqualKey, Allocator > &b)

template<class Key , class MappedType , class Hasher , class EqualKey , class Allocator >
AZ_FORCE_INLINE bool	operator!= (const unordered_multimap< Key, MappedType, Hasher, EqualKey, Allocator > &a, const unordered_multimap< Key, MappedType, Hasher, EqualKey, Allocator > &b)

template<class Key , class MappedType , class Hasher , class EqualKey , class Allocator , class Predicate >
decltype(auto)	erase_if (unordered_multimap< Key, MappedType, Hasher, EqualKey, Allocator > &container, Predicate predicate)

template<class InputIterator , class Hash = hash<iter_key_type<InputIterator>>, class Pred = equal_to<iter_key_type<InputIterator>>, class Allocator = allocator>
	unordered_multimap (InputIterator, InputIterator, typename allocator_traits< Allocator >::size_type={}, Hash=Hash(), Pred=Pred(), Allocator=Allocator()) -> unordered_multimap< iter_key_type< InputIterator >, iter_mapped_type< InputIterator >, Hash, Pred, Allocator >

template<class R , class Hash = hash<range_key_type<R>>, class Pred = equal_to<range_key_type<R>>, class Allocator = allocator, class = enable_if_t<ranges::input_range<R>>>
	unordered_multimap (from_range_t, R &&, typename allocator_traits< Allocator >::size_type={}, Hash=Hash(), Pred=Pred(), Allocator=Allocator()) -> unordered_multimap< range_key_type< R >, range_mapped_type< R >, Hash, Pred, Allocator >

template<class Key , class T , class Hash = hash<Key>, class Pred = equal_to<Key>, class Allocator = allocator>
	unordered_multimap (initializer_list< pair< Key, T > >, typename allocator_traits< Allocator >::size_type={}, Hash=Hash(), Pred=Pred(), Allocator=Allocator()) -> unordered_multimap< Key, T, Hash, Pred, Allocator >

template<class InputIterator , class Allocator >
	unordered_multimap (InputIterator, InputIterator, typename allocator_traits< Allocator >::size_type, Allocator) -> unordered_multimap< iter_key_type< InputIterator >, iter_mapped_type< InputIterator >, hash< iter_key_type< InputIterator > >, equal_to< iter_key_type< InputIterator > >, Allocator >

template<class InputIterator , class Allocator >
	unordered_multimap (InputIterator, InputIterator, Allocator) -> unordered_multimap< iter_key_type< InputIterator >, iter_mapped_type< InputIterator >, hash< iter_key_type< InputIterator > >, equal_to< iter_key_type< InputIterator > >, Allocator >

template<class InputIterator , class Hash , class Allocator >
	unordered_multimap (InputIterator, InputIterator, typename allocator_traits< Allocator >::size_type, Hash, Allocator) -> unordered_multimap< iter_key_type< InputIterator >, iter_mapped_type< InputIterator >, Hash, equal_to< iter_key_type< InputIterator > >, Allocator >

template<class R , class Allocator = allocator, class = enable_if_t<ranges::input_range<R>>>
	unordered_multimap (from_range_t, R &&, typename allocator_traits< Allocator >::size_type, Allocator) -> unordered_multimap< range_key_type< R >, range_mapped_type< R >, hash< range_key_type< R > >, equal_to< range_key_type< R > >, Allocator >

template<class R , class Allocator = allocator, class = enable_if_t<ranges::input_range<R>>>
	unordered_multimap (from_range_t, R &&, Allocator) -> unordered_multimap< range_key_type< R >, range_mapped_type< R >, hash< range_key_type< R > >, equal_to< range_key_type< R > >, Allocator >

template<class R , class Hash , class Allocator , class = enable_if_t<ranges::input_range<R>>>
	unordered_multimap (from_range_t, R &&, typename allocator_traits< Allocator >::size_type, Hash, Allocator=Allocator()) -> unordered_multimap< range_key_type< R >, range_mapped_type< R >, Hash, equal_to< range_key_type< R > >, Allocator >

template<class Key , class T , class Allocator >
	unordered_multimap (initializer_list< pair< Key, T > >, typename allocator_traits< Allocator >::size_type, Allocator) -> unordered_multimap< Key, T, hash< Key >, equal_to< Key >, Allocator >

template<class Key , class T , class Allocator >
	unordered_multimap (initializer_list< pair< Key, T > >, Allocator) -> unordered_multimap< Key, T, hash< Key >, equal_to< Key >, Allocator >

template<class Key , class T , class Hash , class Allocator >
	unordered_multimap (initializer_list< pair< Key, T > >, typename allocator_traits< Allocator >::size_type, Hash, Allocator) -> unordered_multimap< Key, T, Hash, equal_to< Key >, Allocator >

template<class Key , class Hasher , class EqualKey , class Allocator >
AZ_FORCE_INLINE void	swap (unordered_set< Key, Hasher, EqualKey, Allocator > &left, unordered_set< Key, Hasher, EqualKey, Allocator > &right)

template<class Key , class Hasher , class EqualKey , class Allocator >
AZ_FORCE_INLINE bool	operator== (const unordered_set< Key, Hasher, EqualKey, Allocator > &a, const unordered_set< Key, Hasher, EqualKey, Allocator > &b)

template<class Key , class Hasher , class EqualKey , class Allocator >
AZ_FORCE_INLINE bool	operator!= (const unordered_set< Key, Hasher, EqualKey, Allocator > &a, const unordered_set< Key, Hasher, EqualKey, Allocator > &b)

template<class Key , class Hasher , class EqualKey , class Allocator , class Predicate >
decltype(auto)	erase_if (unordered_set< Key, Hasher, EqualKey, Allocator > &container, Predicate predicate)

template<class InputIterator , class Hash = hash<iter_value_type<InputIterator>>, class Pred = equal_to<iter_value_type<InputIterator>>, class Allocator = allocator>
	unordered_set (InputIterator, InputIterator, typename allocator_traits< Allocator >::size_type={}, Hash=Hash(), Pred=Pred(), Allocator=Allocator()) -> unordered_set< iter_value_type< InputIterator >, Hash, Pred, Allocator >

template<class R , class Hash = hash<ranges::range_value_t<R>>, class Pred = equal_to<ranges::range_value_t<R>>, class Allocator = allocator, class = enable_if_t<ranges::input_range<R>>>
	unordered_set (from_range_t, R &&, typename allocator_traits< Allocator >::size_type={}, Hash=Hash(), Pred=Pred(), Allocator=Allocator()) -> unordered_set< ranges::range_value_t< R >, Hash, Pred, Allocator >

template<class T , class Hash = hash<T>, class Pred = equal_to<T>, class Allocator = allocator>
	unordered_set (initializer_list< T >, typename allocator_traits< Allocator >::size_type={}, Hash=Hash(), Pred=Pred(), Allocator=Allocator()) -> unordered_set< T, Hash, Pred, Allocator >

template<class InputIterator , class Allocator >
	unordered_set (InputIterator, InputIterator, typename allocator_traits< Allocator >::size_type, Allocator) -> unordered_set< iter_value_type< InputIterator >, hash< iter_value_type< InputIterator > >, equal_to< iter_value_type< InputIterator > >, Allocator >

template<class InputIterator , class Hash , class Allocator >
	unordered_set (InputIterator, InputIterator, typename allocator_traits< Allocator >::size_type, Hash, Allocator) -> unordered_set< iter_value_type< InputIterator >, Hash, equal_to< iter_value_type< InputIterator > >, Allocator >

template<class R , class Allocator = allocator, class = enable_if_t<ranges::input_range<R>>>
	unordered_set (from_range_t, R &&, typename allocator_traits< Allocator >::size_type, Allocator) -> unordered_set< ranges::range_value_t< R >, hash< ranges::range_value_t< R > >, equal_to< ranges::range_value_t< R > >, Allocator >

template<class R , class Allocator = allocator, class = enable_if_t<ranges::input_range<R>>>
	unordered_set (from_range_t, R &&, Allocator) -> unordered_set< ranges::range_value_t< R >, hash< ranges::range_value_t< R > >, equal_to< ranges::range_value_t< R > >, Allocator >

template<class R , class Hash , class Allocator , class = enable_if_t<ranges::input_range<R>>>
	unordered_set (from_range_t, R &&, typename allocator_traits< Allocator >::size_type, Hash, Allocator=Allocator()) -> unordered_set< ranges::range_value_t< R >, Hash, equal_to< ranges::range_value_t< R > >, Allocator >

template<class T , class Allocator >
	unordered_set (initializer_list< T >, typename allocator_traits< Allocator >::size_type, Allocator) -> unordered_set< T, hash< T >, equal_to< T >, Allocator >

template<class T , class Hash , class Allocator >
	unordered_set (initializer_list< T >, typename allocator_traits< Allocator >::size_type, Hash, Allocator) -> unordered_set< T, Hash, equal_to< T >, Allocator >

template<class Key , class Hasher , class EqualKey , class Allocator >
AZ_FORCE_INLINE void	swap (unordered_multiset< Key, Hasher, EqualKey, Allocator > &left, unordered_multiset< Key, Hasher, EqualKey, Allocator > &right)

template<class Key , class Hasher , class EqualKey , class Allocator >
AZ_FORCE_INLINE bool	operator== (const unordered_multiset< Key, Hasher, EqualKey, Allocator > &a, const unordered_multiset< Key, Hasher, EqualKey, Allocator > &b)

template<class Key , class Hasher , class EqualKey , class Allocator >
AZ_FORCE_INLINE bool	operator!= (const unordered_multiset< Key, Hasher, EqualKey, Allocator > &a, const unordered_multiset< Key, Hasher, EqualKey, Allocator > &b)

template<class Key , class Hasher , class EqualKey , class Allocator , class Predicate >
decltype(auto)	erase_if (unordered_multiset< Key, Hasher, EqualKey, Allocator > &container, Predicate predicate)

template<class InputIterator , class Hash = hash<iter_value_type<InputIterator>>, class Pred = equal_to<iter_value_type<InputIterator>>, class Allocator = allocator>
	unordered_multiset (InputIterator, InputIterator, typename allocator_traits< Allocator >::size_type={}, Hash=Hash(), Pred=Pred(), Allocator=Allocator()) -> unordered_multiset< iter_value_type< InputIterator >, Hash, Pred, Allocator >

template<class R , class Hash = hash<ranges::range_value_t<R>>, class Pred = equal_to<ranges::range_value_t<R>>, class Allocator = allocator, class = enable_if_t<ranges::input_range<R>>>
	unordered_multiset (from_range_t, R &&, typename allocator_traits< Allocator >::size_type={}, Hash=Hash(), Pred=Pred(), Allocator=Allocator()) -> unordered_multiset< ranges::range_value_t< R >, Hash, Pred, Allocator >

template<class T , class Hash = hash<T>, class Pred = equal_to<T>, class Allocator = allocator>
	unordered_multiset (initializer_list< T >, typename allocator_traits< Allocator >::size_type={}, Hash=Hash(), Pred=Pred(), Allocator=Allocator()) -> unordered_multiset< T, Hash, Pred, Allocator >

template<class InputIterator , class Allocator >
	unordered_multiset (InputIterator, InputIterator, typename allocator_traits< Allocator >::size_type, Allocator) -> unordered_multiset< iter_value_type< InputIterator >, hash< iter_value_type< InputIterator > >, equal_to< iter_value_type< InputIterator > >, Allocator >

template<class InputIterator , class Hash , class Allocator >
	unordered_multiset (InputIterator, InputIterator, typename allocator_traits< Allocator >::size_type, Hash, Allocator) -> unordered_multiset< iter_value_type< InputIterator >, Hash, equal_to< iter_value_type< InputIterator > >, Allocator >

template<class R , class Allocator = allocator, class = enable_if_t<ranges::input_range<R>>>
	unordered_multiset (from_range_t, R &&, typename allocator_traits< Allocator >::size_type, Allocator) -> unordered_multiset< ranges::range_value_t< R >, hash< ranges::range_value_t< R > >, equal_to< ranges::range_value_t< R > >, Allocator >

template<class R , class Allocator = allocator, class = enable_if_t<ranges::input_range<R>>>
	unordered_multiset (from_range_t, R &&, Allocator) -> unordered_multiset< ranges::range_value_t< R >, hash< ranges::range_value_t< R > >, equal_to< ranges::range_value_t< R > >, Allocator >

template<class R , class Hash , class Allocator , class = enable_if_t<ranges::input_range<R>>>
	unordered_multiset (from_range_t, R &&, typename allocator_traits< Allocator >::size_type, Hash, Allocator=Allocator()) -> unordered_multiset< ranges::range_value_t< R >, Hash, equal_to< ranges::range_value_t< R > >, Allocator >

template<class T , class Allocator >
	unordered_multiset (initializer_list< T >, typename allocator_traits< Allocator >::size_type, Allocator) -> unordered_multiset< T, hash< T >, equal_to< T >, Allocator >

template<class T , class Hash , class Allocator >
	unordered_multiset (initializer_list< T >, typename allocator_traits< Allocator >::size_type, Hash, Allocator) -> unordered_multiset< T, Hash, equal_to< T >, Allocator >

template<class T , class... Types>
constexpr bool	holds_alternative (const variant< Types... > &variantInst)

template<size_t Index, class... Types>
constexpr variant_alternative_t< Index, variant< Types... > > &	get (variant< Types... > &variantInst)

template<size_t Index, class... Types>
constexpr variant_alternative_t< Index, variant< Types... > > &&	get (variant< Types... > &&variantInst)

template<size_t Index, class... Types>
constexpr const variant_alternative_t< Index, variant< Types... > > &	get (const variant< Types... > &variantInst)

template<size_t Index, class... Types>
constexpr const variant_alternative_t< Index, variant< Types... > > &&	get (const variant< Types... > &&variantInst)

template<class T , class... Types>
constexpr T &	get (variant< Types... > &variantInst)

template<class T , class... Types>
constexpr T &&	get (variant< Types... > &&variantInst)

template<class T , class... Types>
constexpr const T &	get (const variant< Types... > &variantInst)

template<class T , class... Types>
constexpr const T &&	get (const variant< Types... > &&variantInst)

template<size_t Index, class... Types>
constexpr add_pointer_t< variant_alternative_t< Index, variant< Types... > > >	get_if (variant< Types... > *variantInst)

template<size_t Index, class... Types>
constexpr add_pointer_t< const variant_alternative_t< Index, variant< Types... > > >	get_if (const variant< Types... > *variantInst)

template<class T , class... Types>
constexpr add_pointer_t< T >	get_if (variant< Types... > *variantInst)

template<class T , class... Types>
constexpr add_pointer_t< const T >	get_if (const variant< Types... > *variantInst)

template<class... Types>
constexpr bool	operator== (const variant< Types... > &lhs, const variant< Types... > &rhs)

template<class... Types>
constexpr bool	operator!= (const variant< Types... > &lhs, const variant< Types... > &rhs)

template<class... Types>
constexpr bool	operator< (const variant< Types... > &lhs, const variant< Types... > &rhs)

template<class... Types>
constexpr bool	operator> (const variant< Types... > &lhs, const variant< Types... > &rhs)

template<class... Types>
constexpr bool	operator<= (const variant< Types... > &lhs, const variant< Types... > &rhs)

template<class... Types>
constexpr bool	operator>= (const variant< Types... > &lhs, const variant< Types... > &rhs)

template<typename... Types>
constexpr void	swap (variant< Types... > &lhs, variant< Types... > &rhs)

template<class Visitor , class... Variants>
constexpr decltype(auto)	visit (Visitor &&visitor, Variants &&... variants)

template<class R , class Visitor , class... Variants>
constexpr R	visit (Visitor &&visitor, Variants &&... variants)

constexpr bool	operator< (monostate, monostate)

constexpr bool	operator> (monostate, monostate)

constexpr bool	operator<= (monostate, monostate)

constexpr bool	operator>= (monostate, monostate)

constexpr bool	operator== (monostate, monostate)

constexpr bool	operator!= (monostate, monostate)

template<class Visitor , class... VariantTypes>
constexpr decltype(auto)	visit (Visitor &&visitor, VariantTypes &&... variants)

template<class R , class Visitor , class... VariantTypes>
constexpr R	visit (Visitor &&visitor, VariantTypes &&... variants)

constexpr size_t	find_index_return (size_t currentIndex, size_t resultIndex, bool doesIndexMatch)

template<size_t IndexMax>
constexpr size_t	find_index (size_t currentIndex, const bool(&matches)[IndexMax])

template<class InputIt , class Alloc = allocator>
	vector (InputIt, InputIt, Alloc=Alloc()) -> vector< iter_value_t< InputIt >, Alloc >

template<class R , class Alloc = allocator, class = enable_if_t<ranges::input_range<R>>>
	vector (from_range_t, R &&, Alloc=Alloc()) -> vector< ranges::range_value_t< R >, Alloc >

template<class T , class Allocator >
AZ_FORCE_INLINE bool	operator== (const vector< T, Allocator > &a, const vector< T, Allocator > &b)

template<class T , class Allocator >
AZ_FORCE_INLINE bool	operator!= (const vector< T, Allocator > &a, const vector< T, Allocator > &b)

template<class T , class Allocator , class U >
decltype(auto)	erase (vector< T, Allocator > &container, const U &value)

template<class T , class Allocator , class Predicate >
decltype(auto)	erase_if (vector< T, Allocator > &container, Predicate predicate)

template<typename T >
constexpr void	destroy_at (T *ptr)

template<typename ForwardIt >
constexpr void	destroy (ForwardIt first, ForwardIt last)

template<typename ForwardIt , size_t N>
constexpr ForwardIt	destroy_n (ForwardIt first, size_t numElements)

template<typename T , typename... Args>
constexpr auto	construct_at (T ptr, Args &&... args) -> decltype(new(AZStd::declval< void >()) T(AZStd::forward< Args >(args)...),(T *) nullptr)

template<class InputIterator , class ForwardIterator >
constexpr ForwardIterator	uninitialized_copy (InputIterator first, InputIterator last, ForwardIterator result, bool)

template<class InputIterator , class ForwardIterator >
constexpr ForwardIterator	uninitialized_copy (InputIterator first, InputIterator last, ForwardIterator result)

template<class InputIterator , class OutputIterator >
constexpr OutputIterator	copy (InputIterator first, InputIterator last, OutputIterator result)

template<class BidirectionalIterator , class OutputIterator >
constexpr OutputIterator	reverse_copy (BidirectionalIterator first, BidirectionalIterator last, OutputIterator dest)

template<class BidirectionalIterator1 , class BidirectionalIterator2 >
BidirectionalIterator2	copy_backward (BidirectionalIterator1 first, BidirectionalIterator1 last, BidirectionalIterator2 result)

template<typename InputIt , typename ForwardIt >
ForwardIt	uninitialized_move (InputIt first, InputIt last, ForwardIt result)

template<class InputIterator , class OutputIterator >
OutputIterator	move (InputIterator first, InputIterator last, OutputIterator result)

template<class BidirectionalIterator1 , class BidirectionalIterator2 >
BidirectionalIterator2	move_backward (BidirectionalIterator1 first, BidirectionalIterator1 last, BidirectionalIterator2 result)

template<class ForwardIterator , class T >
constexpr void	fill (ForwardIterator first, ForwardIterator last, const T &value)

template<class ForwardIterator , class Size , class T >
constexpr void	fill_n (ForwardIterator first, Size numElements, const T &value)

template<class ForwardIterator , class T >
constexpr void	uninitialized_fill (ForwardIterator first, ForwardIterator last, const T &value, bool)

template<class ForwardIterator , class Size , class T >
constexpr void	uninitialized_fill (ForwardIterator first, Size numElements, const T &value)

template<class ForwardIterator , class Size , class T >
constexpr void	uninitialized_fill_n (ForwardIterator first, Size numElements, const T &value, bool)

template<class ForwardIterator , class Size , class T >
constexpr void	uninitialized_fill_n (ForwardIterator first, Size numElements, const T &value)

template<class X , class Y , class R >
delegate< R()>	make_delegate (Y x, R(X::func)())

template<class X , class Y , class Param1 , class R >
delegate< R(Param1) >	make_delegate (Y x, R(X::func)(Param1 p1))

template<class X , class Y , class Param1 , class Param2 , class R >
delegate< R(Param1, Param2)>	make_delegate (Y x, R(X::func)(Param1 p1, Param2 p2))

template<class X , class Y , class Param1 , class Param2 , class Param3 , class R >
delegate< R(Param1, Param2, Param3)>	make_delegate (Y x, R(X::func)(Param1 p1, Param2 p2, Param3 p3))

template<class X , class Y , class Param1 , class Param2 , class Param3 , class Param4 , class R >
delegate< R(Param1, Param2, Param3, Param4)>	make_delegate (Y x, R(X::func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4))

template<class X , class Y , class Param1 , class Param2 , class Param3 , class Param4 , class Param5 , class R >
delegate< R(Param1, Param2, Param3, Param4, Param5)>	make_delegate (Y x, R(X::func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5))

template<class X , class Y , class Param1 , class Param2 , class Param3 , class Param4 , class Param5 , class Param6 , class R >
delegate< R(Param1, Param2, Param3, Param4, Param5, Param6)>	make_delegate (Y x, R(X::func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6))

template<class X , class Y , class Param1 , class Param2 , class Param3 , class Param4 , class Param5 , class Param6 , class Param7 , class R >
delegate< R(Param1, Param2, Param3, Param4, Param5, Param6, Param7)>	make_delegate (Y x, R(X::func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7))

template<class X , class Y , class Param1 , class Param2 , class Param3 , class Param4 , class Param5 , class Param6 , class Param7 , class Param8 , class R >
delegate< R(Param1, Param2, Param3, Param4, Param5, Param6, Param7, Param8)>	make_delegate (Y x, R(X::func)(Param1 p1, Param2 p2, Param3 p3, Param4 p4, Param5 p5, Param6 p6, Param7 p7, Param8 p8))

bool	operator== (const function_base &f, Internal::function_util::useless_clear_type *)

bool	operator!= (const function_base &f, Internal::function_util::useless_clear_type *)

bool	operator== (Internal::function_util::useless_clear_type *, const function_base &f)

bool	operator!= (Internal::function_util::useless_clear_type *, const function_base &f)

template<typename Functor >
	operator== (const function_base &f, Functor g)

template<typename Functor >
	operator== (Functor g, const function_base &f)

template<typename Functor >
	operator!= (const function_base &f, Functor g)

template<typename Functor >
	operator!= (Functor g, const function_base &f)

template<typename Functor >
	operator== (const function_base &f, reference_wrapper< Functor > g)

template<typename Functor >
	operator== (reference_wrapper< Functor > g, const function_base &f)

template<typename Functor >
	operator!= (const function_base &f, reference_wrapper< Functor > g)

template<typename Functor >
	operator!= (reference_wrapper< Functor > g, const function_base &f)

template<typename Signature >
void	swap (function< Signature > &f1, function< Signature > &f2)

template<typename R , typename... Args>
void	swap (function_intermediate< R, Args... > &f1, function_intermediate< R, Args... > &f2)

template<typename R , typename... Args>
void	operator== (const function_intermediate< R, Args... > &, const function_intermediate< R, Args... > &)=delete

template<typename R , typename... Args>
void	operator!= (const function_intermediate< R, Args... > &, const function_intermediate< R, Args... > &)=delete

template<class R , class... ArgTypes>
	function (R(*)(ArgTypes...)) -> function< R(ArgTypes...)>

template<class F , class = enable_if_t<AZStd::Internal::has_call_operator_v<F>>>
	function (F) -> function< typename AZStd::Internal::function_object< F >::function_type >

template<class F , class... Args>
constexpr invoke_result_t< F, Args... >	invoke (F &&f, Args &&... args)

template<class I >
constexpr auto	make_const_iterator (I it) -> enable_if_t< input_iterator< I >, const_iterator< I > >

template<class S >
constexpr const_sentinel< S >	make_const_sentinel (S s)

template<class I >
constexpr move_iterator< I >	make_move_iterator (I i)

constexpr float	lerp (float a, float b, float t) noexcept

constexpr double	lerp (double a, double b, double t) noexcept

constexpr long double	lerp (long double a, long double b, long double t) noexcept

template<typename InputIt , typename T >
constexpr T	accumulate (InputIt first, InputIt last, T init)

template<typename InputIt , typename T , typename BinaryOperation >
constexpr T	accumulate (InputIt first, InputIt last, T init, BinaryOperation op)

template<class InputIt1 , class InputIt2 , class T >
constexpr T	inner_product (InputIt1 first1, InputIt1 last1, InputIt2 first2, T init)

template<class InputIt1 , class InputIt2 , class T , class BinaryOperation1 , class BinaryOperation2 >
constexpr T	inner_product (InputIt1 first1, InputIt1 last1, InputIt2 first2, T init, BinaryOperation1 op1, BinaryOperation2 op2)

template<class Node , AZStd::size_t NumNodes>
AZ_FORCE_INLINE bool	operator== (const static_pool_concurrent_allocator< Node, NumNodes > &a, const static_pool_concurrent_allocator< Node, NumNodes > &b)

template<class Node , AZStd::size_t NumNodes>
AZ_FORCE_INLINE bool	operator!= (const static_pool_concurrent_allocator< Node, NumNodes > &a, const static_pool_concurrent_allocator< Node, NumNodes > &b)

bool	operator== (AZStd::thread_id x, AZStd::thread_id y)

bool	operator!= (AZStd::thread_id x, AZStd::thread_id y)

bool	operator< (AZStd::thread_id x, AZStd::thread_id y)

bool	operator<= (AZStd::thread_id x, AZStd::thread_id y)

bool	operator> (AZStd::thread_id x, AZStd::thread_id y)

bool	operator>= (AZStd::thread_id x, AZStd::thread_id y)

template<class Key , class MappedType , AZStd::size_t FixedNumBuckets, AZStd::size_t FixedNumElements, AZStd::size_t NumLocks, class Hasher , class EqualKey >
AZ_FORCE_INLINE void	swap (concurrent_fixed_unordered_map< Key, MappedType, FixedNumBuckets, FixedNumElements, NumLocks, Hasher, EqualKey > &left, concurrent_fixed_unordered_map< Key, MappedType, FixedNumBuckets, FixedNumElements, NumLocks, Hasher, EqualKey > &right)

template<class Key , class MappedType , AZStd::size_t FixedNumBuckets, AZStd::size_t FixedNumElements, AZStd::size_t NumLocks, class Hasher , class EqualKey >
AZ_FORCE_INLINE void	swap (concurrent_fixed_unordered_multimap< Key, MappedType, FixedNumBuckets, FixedNumElements, NumLocks, Hasher, EqualKey > &left, concurrent_fixed_unordered_multimap< Key, MappedType, FixedNumBuckets, FixedNumElements, NumLocks, Hasher, EqualKey > &right)

template<class Key , AZStd::size_t FixedNumBuckets, AZStd::size_t FixedNumElements, AZStd::size_t NumLocks, class Hasher , class EqualKey >
AZ_FORCE_INLINE void	swap (concurrent_fixed_unordered_set< Key, FixedNumBuckets, FixedNumElements, NumLocks, Hasher, EqualKey > &left, concurrent_fixed_unordered_set< Key, FixedNumBuckets, FixedNumElements, NumLocks, Hasher, EqualKey > &right)

template<class Key , AZStd::size_t FixedNumBuckets, AZStd::size_t FixedNumElements, AZStd::size_t NumLocks, class Hasher , class EqualKey >
AZ_FORCE_INLINE void	swap (concurrent_fixed_unordered_multiset< Key, FixedNumBuckets, FixedNumElements, NumLocks, Hasher, EqualKey > &left, concurrent_fixed_unordered_multiset< Key, FixedNumBuckets, FixedNumElements, NumLocks, Hasher, EqualKey > &right)

template<class Key , class MappedType , AZStd::size_t NumLocks, class Hasher , class EqualKey , class Allocator >
AZ_FORCE_INLINE void	swap (concurrent_unordered_map< Key, MappedType, NumLocks, Hasher, EqualKey, Allocator > &left, concurrent_unordered_map< Key, MappedType, NumLocks, Hasher, EqualKey, Allocator > &right)

template<class Key , class MappedType , AZStd::size_t NumLocks, class Hasher , class EqualKey , class Allocator >
AZ_FORCE_INLINE void	swap (concurrent_unordered_multimap< Key, MappedType, NumLocks, Hasher, EqualKey, Allocator > &left, concurrent_unordered_multimap< Key, MappedType, NumLocks, Hasher, EqualKey, Allocator > &right)

template<class Key , AZStd::size_t NumLocks, class Hasher , class EqualKey , class Allocator >
AZ_FORCE_INLINE void	swap (concurrent_unordered_set< Key, NumLocks, Hasher, EqualKey, Allocator > &left, concurrent_unordered_set< Key, NumLocks, Hasher, EqualKey, Allocator > &right)

template<class Key , AZStd::size_t NumLocks, class Hasher , class EqualKey , class Allocator >
AZ_FORCE_INLINE void	swap (concurrent_unordered_multiset< Key, NumLocks, Hasher, EqualKey, Allocator > &left, concurrent_unordered_multiset< Key, NumLocks, Hasher, EqualKey, Allocator > &right)

template<class Mutex >
void	swap (unique_lock< Mutex > &x, unique_lock< Mutex > &y)

template<class Lockable1 , class Lockable2 >
int	try_lock (Lockable1 &lockable1, Lockable2 &lockable2)

template<class Lockable1 , class Lockable2 , class Lockable3 , class... LockableN>
int	try_lock (Lockable1 &lockable1, Lockable2 &lockable2, Lockable3 &lockable3, LockableN &... lockableN)

template<class Lockable >
void	lock (Lockable &lockable)

template<class Lockable1 , class Lockable2 >
void	lock (Lockable1 &lockable1, Lockable2 &lockable2)

template<class Lockable1 , class Lockable2 , class Lockable3 , class... LockableN>
void	lock_helper (int32_t mutexWhichFailedToLockIndex, Lockable1 &lockable1, Lockable2 &lockable2, Lockable3 &lockable3, LockableN &... lockableN)

template<class Lockable1 , class Lockable2 , class Lockable3 , class... LockableN>
void	lock (Lockable1 &lockable1, Lockable2 &lockable2, Lockable3 &lockable3, LockableN &... lockableN)

template<class Lockable >
void	unlock (Lockable &lockable)

template<class Lockable1 , class Lockable2 >
void	unlock (Lockable1 &lockable1, Lockable2 &lockable2)

template<class Lockable1 , class Lockable2 , class Lockable3 , class... LockableN>
void	unlock (Lockable1 &lockable1, Lockable2 &lockable2, Lockable3 &lockable3, LockableN &... lockableN)

void	swap (thread &x, thread &y)

template<class T >
void	checked_delete (T *x)

template<class T >
void	checked_array_delete (T *x)

template<class T , class U >
bool	operator== (intrusive_ptr< T > const &a, intrusive_ptr< U > const &b)

template<class T , class U >
bool	operator!= (intrusive_ptr< T > const &a, intrusive_ptr< U > const &b)

template<class T , class U >
bool	operator== (intrusive_ptr< T > const &a, U *b)

template<class T , class U >
bool	operator!= (intrusive_ptr< T > const &a, U *b)

template<class T , class U >
bool	operator== (T *a, intrusive_ptr< U > const &b)

template<class T , class U >
bool	operator!= (T *a, intrusive_ptr< U > const &b)

template<class T >
bool	operator< (intrusive_ptr< T > const &a, intrusive_ptr< T > const &b)

template<class T >
void	swap (intrusive_ptr< T > &lhs, intrusive_ptr< T > &rhs)

template<class T >
T *	get_pointer (intrusive_ptr< T > const &p)

template<class T , class U >
intrusive_ptr< T >	static_pointer_cast (intrusive_ptr< U > const &p)

template<class T , class U >
intrusive_ptr< T >	const_pointer_cast (intrusive_ptr< U > const &p)

template<class T , class U >
intrusive_ptr< T >	dynamic_pointer_cast (intrusive_ptr< U > const &p)

template<class T >
AZStd::shared_ptr< T >	make_shared ()

template<class T , class A >
AZStd::shared_ptr< T >	allocate_shared (A const &a)

template<class T , class ... Args>
AZStd::shared_ptr< T >	make_shared (Args &&... args)

template<class T , class A , class Arg1 , class ... Args>
AZStd::shared_ptr< T >	allocate_shared (A const &a, Arg1 &&arg1, Args &&... args)

template<class T >
void	swap (scoped_array< T > &a, scoped_array< T > &b)

template<class T >
void	swap (scoped_ptr< T > &a, scoped_ptr< T > &b)

template<class T >
T *	get_pointer (scoped_ptr< T > const &p)

template<class T >
bool	operator== (shared_array< T > const &a, shared_array< T > const &b)

template<class T >
bool	operator!= (shared_array< T > const &a, shared_array< T > const &b)

template<class T >
bool	operator< (shared_array< T > const &a, shared_array< T > const &b)

template<class T >
void	swap (shared_array< T > &a, shared_array< T > &b)

template<class T >
	shared_ptr (AZStd::weak_ptr< T >) -> shared_ptr< T >

template<class T , class D >
	shared_ptr (AZStd::unique_ptr< T, D >) -> shared_ptr< T >

template<class T , class U >
bool	operator== (shared_ptr< T > const &a, shared_ptr< U > const &b)

template<class T , class U >
bool	operator!= (shared_ptr< T > const &a, shared_ptr< U > const &b)

template<class T , class U >
bool	operator< (shared_ptr< T > const &a, shared_ptr< U > const &b)

template<class T >
void	swap (shared_ptr< T > &a, shared_ptr< T > &b)

template<class T , class U >
shared_ptr< T >	static_pointer_cast (shared_ptr< U > const &r)

template<class T , class U >
shared_ptr< T >	const_pointer_cast (shared_ptr< U > const &r)

template<class T , class U >
shared_ptr< T >	reinterpret_pointer_cast (shared_ptr< U > const &r)

template<class T , class U >
shared_ptr< T >	rtti_pointer_cast (shared_ptr< U > const &r)

template<class T >
T *	get_pointer (shared_ptr< T > const &p)

template<class D , class T >
D *	get_deleter (shared_ptr< T > const &p)

template<typename T , typename... Args>
AZStd::enable_if_t<!AZStd::is_array< T >::value &&AZ::HasAZClassAllocator< T >::value, unique_ptr< T > >	make_unique (Args &&... args)

template<typename T , typename... Args>
AZStd::enable_if_t<!AZStd::is_array< T >::value &&!AZ::HasAZClassAllocator< T >::value, unique_ptr< T > >	make_unique (Args &&... args)

template<typename T >
AZStd::enable_if_t< AZStd::is_array< T >::value &&AZStd::extent< T >::value==0, unique_ptr< T > >	make_unique (std::size_t size)

template<typename T , typename... Args>
AZStd::enable_if_t< AZStd::is_array< T >::value &&AZStd::extent< T >::value !=0, unique_ptr< T > >	make_unique (Args &&... args)=delete

template<class T , class U >
bool	operator< (weak_ptr< T > const &a, weak_ptr< U > const &b)

template<class T >
void	swap (weak_ptr< T > &a, weak_ptr< T > &b)

template<class InputIterator1 , class InputIterator2 , class OutputIterator >
OutputIterator	merge (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result)

template<class InputIterator1 , class InputIterator2 , class OutputIterator , class Compare >
OutputIterator	merge (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp)

template<class BidirectionalIterator1 , class BidirectionalIterator2 , class BidirectionalIterator3 , class Compare >
BidirectionalIterator3	merge_backward (BidirectionalIterator1 first1, BidirectionalIterator1 last1, BidirectionalIterator2 first2, BidirectionalIterator2 last2, BidirectionalIterator3 result, Compare comp)

template<class BidirectionalIterator , class Difference , class Buffer , class Compare >
void	merge_buffered (BidirectionalIterator first, BidirectionalIterator mid, BidirectionalIterator last, Difference count1, Difference count2, Buffer &buffer, Compare comp)

template<class BidirectionalIterator , class Difference , class Buffer >
BidirectionalIterator	buffered_rotate (BidirectionalIterator first, BidirectionalIterator mid, BidirectionalIterator last, Difference count1, Difference count2, Buffer &buffer)

template<class RandomAccessIterator , class Compare >
void	partial_sort (RandomAccessIterator first, RandomAccessIterator middle, RandomAccessIterator last, Compare comp)

template<class RandomAccessIterator >
void	partial_sort (RandomAccessIterator first, RandomAccessIterator middle, RandomAccessIterator last)

template<class RandomAccessIterator >
void	insertion_sort (RandomAccessIterator first, RandomAccessIterator last)

template<class RandomAccessIterator , class Compare >
void	insertion_sort (RandomAccessIterator first, RandomAccessIterator last, Compare comp)

template<class Element , class Traits , class Allocator1 , class Allocator2 >
AZ_FORCE_INLINE int	alphanum_comp (const basic_string< Element, Traits, Allocator1 > &l, const basic_string< Element, Traits, Allocator2 > &r)

AZ_FORCE_INLINE int	alphanum_comp (const char l, const char r)

template<class Element , class Traits , class Allocator >
AZ_FORCE_INLINE int	alphanum_comp (const basic_string< Element, Traits, Allocator > &l, const char *r)

template<class Element , class Traits , class Allocator >
AZ_FORCE_INLINE int	alphanum_comp (const char *l, const basic_string< Element, Traits, Allocator > &r)

template<class Allocator >
int	stoi (const AZStd::basic_string< AZStd::string::value_type, AZStd::string::traits_type, Allocator > &str, AZStd::size_t *idx=0, int base=10)

template<class Allocator >
long	stol (const AZStd::basic_string< AZStd::string::value_type, AZStd::string::traits_type, Allocator > &str, AZStd::size_t *idx=0, int base=10)

template<class Allocator >
unsigned long	stoul (const AZStd::basic_string< AZStd::string::value_type, AZStd::string::traits_type, Allocator > &str, AZStd::size_t *idx=0, int base=10)

template<class Allocator >
long long	stoll (const AZStd::basic_string< AZStd::string::value_type, AZStd::string::traits_type, Allocator > &str, size_t *idx=0, int base=10)

template<class Allocator >
unsigned long long	stoull (const AZStd::basic_string< AZStd::string::value_type, AZStd::string::traits_type, Allocator > &str, size_t *idx=0, int base=10)

template<class Allocator >
float	stof (const AZStd::basic_string< AZStd::string::value_type, AZStd::string::traits_type, Allocator > &str, AZStd::size_t *idx=0)

template<class Allocator >
double	stod (const AZStd::basic_string< AZStd::string::value_type, AZStd::string::traits_type, Allocator > &str, AZStd::size_t *idx=0)

template<class Str >
void	to_string (Str &str, int value)

template<class Str >
void	to_string (Str &str, unsigned int value)

template<class Str >
void	to_string (Str &str, float value)

template<class Str >
void	to_string (Str &str, double value)

template<class Str >
void	to_string (Str &str, long value)

template<class Str >
void	to_string (Str &str, unsigned long value)

template<class Str >
void	to_string (Str &str, long long value)

template<class Str >
void	to_string (Str &str, unsigned long long value)

template<class Str >
void	to_string (Str &str, long double value)

template<class Str , class BoolType >
auto	to_string (Str &str, BoolType value) -> enable_if_t< same_as< remove_cvref_t< BoolType >, bool > >

AZStd::string	to_string (int val)

AZStd::string	to_string (unsigned int val)

AZStd::string	to_string (float val)

AZStd::string	to_string (double val)

AZStd::string	to_string (long val)

AZStd::string	to_string (unsigned long val)

AZStd::string	to_string (long long val)

AZStd::string	to_string (unsigned long long val)

AZStd::string	to_string (long double val)

template<class BoolType >
auto	to_string (BoolType value) -> enable_if_t< same_as< remove_cvref_t< BoolType >, bool >, AZStd::string >

template<class Allocator >
void	to_string (AZStd::basic_string< string::value_type, string::traits_type, Allocator > &dest, AZStd::wstring_view src)

template<size_t MaxElementCount>
void	to_string (AZStd::basic_fixed_string< string::value_type, MaxElementCount, string::traits_type > &dest, AZStd::wstring_view src)

void	to_string (char *dest, size_t destSize, AZStd::wstring_view src)

size_t	to_string_length (AZStd::wstring_view src)

template<class Str >
void	to_wstring (Str &str, long long value)

template<class Str >
void	to_wstring (Str &str, unsigned long long value)

template<class Str >
void	to_wstring (Str &str, long double value)

AZStd::wstring	to_wstring (long long val)

AZStd::wstring	to_wstring (unsigned long long val)

AZStd::wstring	to_wstring (long double val)

template<class Allocator >
bool	to_wstring (AZStd::basic_string< wstring::value_type, wstring::traits_type, Allocator > &dest, AZStd::string_view src)

template<size_t MaxElementCount>
bool	to_wstring (AZStd::basic_fixed_string< wstring::value_type, MaxElementCount, wstring::traits_type > &dest, AZStd::string_view src)

bool	to_wstring (wchar_t *dest, size_t destSize, AZStd::string_view src)

AZ_FORCE_INLINE size_t	str_transform (char destination, const char source, size_t count)

AZ_FORCE_INLINE size_t	str_transform (wchar_t destination, const wchar_t source, size_t count)

template<class CharT >
bool	isalnum (CharT ch, const std::locale &loc={})

template<class CharT >
bool	isalpha (CharT ch, const std::locale &loc={})

template<class CharT >
bool	isblank (CharT ch, const std::locale &loc={})

template<class CharT >
bool	iscntrl (CharT ch, const std::locale &loc={})

template<class CharT >
bool	isdigit (CharT ch, const std::locale &loc={})

template<class CharT >
bool	isgraph (CharT ch, const std::locale &loc={})

template<class CharT >
bool	islower (CharT ch, const std::locale &loc={})

template<class CharT >
bool	isprint (CharT ch, const std::locale &loc={})

template<class CharT >
bool	ispunct (CharT ch, const std::locale &loc={})

template<class CharT >
bool	isspace (CharT ch, const std::locale &loc={})

template<class CharT >
bool	isupper (CharT ch, const std::locale &loc={})

template<class CharT >
bool	isxdigit (CharT ch, const std::locale &loc={})

template<class CharT >
bool	is_alnum (CharT ch, const std::locale &loc={})

template<class CharT >
bool	is_alpha (CharT ch, const std::locale &loc={})

template<class CharT >
bool	is_blank (CharT ch, const std::locale &loc={})

template<class CharT >
bool	is_cntrl (CharT ch, const std::locale &loc={})

template<class CharT >
bool	is_digit (CharT ch, const std::locale &loc={})

template<class CharT >
bool	is_graph (CharT ch, const std::locale &loc={})

template<class CharT >
bool	is_lower (CharT ch, const std::locale &loc={})

template<class CharT >
bool	is_print (CharT ch, const std::locale &loc={})

template<class CharT >
bool	is_punct (CharT ch, const std::locale &loc={})

template<class CharT >
bool	is_space (CharT ch, const std::locale &loc={})

template<class CharT >
bool	is_upper (CharT ch, const std::locale &loc={})

template<class CharT >
bool	is_xdigit (CharT ch, const std::locale &loc={})

template<class charT >
charT	tolower (charT ch, const std::locale &loc={})

template<class charT >
charT	toupper (charT ch, const std::locale &loc={})

template<class Iterator >
void	to_lower (Iterator first, Iterator last, const std::locale &loc={})

template<class Range >
auto	to_lower (Range &&r, const std::locale &loc={}) -> enable_if_t< ranges::range< Range > &&indirectly_copyable< ranges::iterator_t< Range >, ranges::iterator_t< Range > > >

template<class Iterator >
void	to_upper (Iterator first, Iterator last, const std::locale &loc={})

template<class Range >
auto	to_upper (Range &&r, const std::locale &loc={}) -> enable_if_t< ranges::range< Range > &&indirectly_copyable< ranges::iterator_t< Range >, ranges::iterator_t< Range > > >

template<class T , class... U>
	basic_fixed_string (T, U...) -> basic_fixed_string< T, 1+sizeof...(U), AZStd::char_traits< T > >

template<class T , auto N>
	basic_fixed_string (const T(&)[N]) -> basic_fixed_string< T, N - 1, AZStd::char_traits< T > >

template<class Element , size_t MaxElementCount, class Traits >
constexpr void	swap (basic_fixed_string< Element, MaxElementCount, Traits > &left, basic_fixed_string< Element, MaxElementCount, Traits > &right)

template<class Element , size_t MaxElementCount, class Traits >
constexpr basic_fixed_string< Element, MaxElementCount, Traits >	operator+ (const basic_fixed_string< Element, MaxElementCount, Traits > &lhs, const basic_fixed_string< Element, MaxElementCount, Traits > &rhs)

template<class Element , size_t MaxElementCount, class Traits >
constexpr basic_fixed_string< Element, MaxElementCount, Traits >	operator+ (const basic_fixed_string< Element, MaxElementCount, Traits > &lhs, const Element *rhs)

template<class Element , size_t MaxElementCount, class Traits >
constexpr basic_fixed_string< Element, MaxElementCount, Traits >	operator+ (const basic_fixed_string< Element, MaxElementCount, Traits > &lhs, Element rhs)

template<class Element , size_t MaxElementCount, class Traits >
constexpr basic_fixed_string< Element, MaxElementCount, Traits >	operator+ (const Element *lhs, const basic_fixed_string< Element, MaxElementCount, Traits > &rhs)

template<class Element , size_t MaxElementCount, class Traits >
constexpr basic_fixed_string< Element, MaxElementCount, Traits >	operator+ (Element lhs, const basic_fixed_string< Element, MaxElementCount, Traits > &rhs)

template<class Element , size_t MaxElementCount, class Traits >
constexpr basic_fixed_string< Element, MaxElementCount, Traits >	operator+ (basic_fixed_string< Element, MaxElementCount, Traits > &&lhs, basic_fixed_string< Element, MaxElementCount, Traits > &&rhs)

template<class Element , size_t MaxElementCount, class Traits >
constexpr basic_fixed_string< Element, MaxElementCount, Traits >	operator+ (basic_fixed_string< Element, MaxElementCount, Traits > &&lhs, const basic_fixed_string< Element, MaxElementCount, Traits > &rhs)

template<class Element , size_t MaxElementCount, class Traits >
constexpr basic_fixed_string< Element, MaxElementCount, Traits >	operator+ (basic_fixed_string< Element, MaxElementCount, Traits > &&lhs, const Element *rhs)

template<class Element , size_t MaxElementCount, class Traits >
constexpr basic_fixed_string< Element, MaxElementCount, Traits >	operator+ (basic_fixed_string< Element, MaxElementCount, Traits > &&lhs, Element rhs)

template<class Element , size_t MaxElementCount, class Traits >
constexpr basic_fixed_string< Element, MaxElementCount, Traits >	operator+ (const basic_fixed_string< Element, MaxElementCount, Traits > &lhs, basic_fixed_string< Element, MaxElementCount, Traits > &&rhs)

template<class Element , size_t MaxElementCount, class Traits >
constexpr basic_fixed_string< Element, MaxElementCount, Traits >	operator+ (const Element *lhs, basic_fixed_string< Element, MaxElementCount, Traits > &&rhs)

template<class Element , size_t MaxElementCount, class Traits >
constexpr basic_fixed_string< Element, MaxElementCount, Traits >	operator+ (Element lhs, basic_fixed_string< Element, MaxElementCount, Traits > &&rhs)

template<class Element , size_t MaxElementCount, class Traits >
constexpr bool	operator== (const basic_fixed_string< Element, MaxElementCount, Traits > &lhs, const basic_fixed_string< Element, MaxElementCount, Traits > &rhs)

template<class Element , size_t MaxElementCount, class Traits >
constexpr bool	operator== (const Element *lhs, const basic_fixed_string< Element, MaxElementCount, Traits > &rhs)

template<class Element , size_t MaxElementCount, class Traits >
constexpr bool	operator== (const basic_fixed_string< Element, MaxElementCount, Traits > &lhs, const Element *rhs)

template<class Element , size_t MaxElementCount, class Traits >
constexpr bool	operator!= (const basic_fixed_string< Element, MaxElementCount, Traits > &lhs, const basic_fixed_string< Element, MaxElementCount, Traits > &rhs)

template<class Element , size_t MaxElementCount, class Traits >
constexpr bool	operator!= (const Element *lhs, const basic_fixed_string< Element, MaxElementCount, Traits > &rhs)

template<class Element , size_t MaxElementCount, class Traits >
constexpr bool	operator!= (const basic_fixed_string< Element, MaxElementCount, Traits > &lhs, const Element *rhs)

template<class Element , size_t MaxElementCount, class Traits >
constexpr bool	operator< (const basic_fixed_string< Element, MaxElementCount, Traits > &lhs, const basic_fixed_string< Element, MaxElementCount, Traits > &rhs)

template<class Element , size_t MaxElementCount, class Traits >
constexpr bool	operator< (const basic_fixed_string< Element, MaxElementCount, Traits > &lhs, const Element *rhs)

template<class Element , size_t MaxElementCount, class Traits >
constexpr bool	operator< (const Element *lhs, const basic_fixed_string< Element, MaxElementCount, Traits > &rhs)

template<class Element , size_t MaxElementCount, class Traits >
constexpr bool	operator> (const basic_fixed_string< Element, MaxElementCount, Traits > &lhs, const basic_fixed_string< Element, MaxElementCount, Traits > &rhs)

template<class Element , size_t MaxElementCount, class Traits >
constexpr bool	operator> (const basic_fixed_string< Element, MaxElementCount, Traits > &lhs, const Element *rhs)

template<class Element , size_t MaxElementCount, class Traits >
constexpr bool	operator> (const Element *lhs, const basic_fixed_string< Element, MaxElementCount, Traits > &rhs)

template<class Element , size_t MaxElementCount, class Traits >
constexpr bool	operator<= (const basic_fixed_string< Element, MaxElementCount, Traits > &lhs, const basic_fixed_string< Element, MaxElementCount, Traits > &rhs)

template<class Element , size_t MaxElementCount, class Traits >
constexpr bool	operator<= (const basic_fixed_string< Element, MaxElementCount, Traits > &lhs, const Element *rhs)

template<class Element , size_t MaxElementCount, class Traits >
constexpr bool	operator<= (const Element *lhs, const basic_fixed_string< Element, MaxElementCount, Traits > &rhs)

template<class Element , size_t MaxElementCount, class Traits >
constexpr bool	operator>= (const basic_fixed_string< Element, MaxElementCount, Traits > &lhs, const basic_fixed_string< Element, MaxElementCount, Traits > &rhs)

template<class Element , size_t MaxElementCount, class Traits >
constexpr bool	operator>= (const basic_fixed_string< Element, MaxElementCount, Traits > &lhs, const Element *rhs)

template<class Element , size_t MaxElementCount, class Traits >
constexpr bool	operator>= (const Element *lhs, const basic_fixed_string< Element, MaxElementCount, Traits > &rhs)

template<class Element , size_t MaxElementCount, class Traits , class U >
constexpr auto	erase (basic_fixed_string< Element, MaxElementCount, Traits > &container, const U &element) -> typename basic_fixed_string< Element, MaxElementCount, Traits >::size_type

template<class Element , size_t MaxElementCount, class Traits , class Predicate >
constexpr auto	erase_if (basic_fixed_string< Element, MaxElementCount, Traits > &container, Predicate predicate) -> typename basic_fixed_string< Element, MaxElementCount, Traits >::size_type

template<class InputIterator1 , class InputIterator2 , class Predicate >
bool	IsSame (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, Predicate pred)

template<class BidirectionalIterator >
bool	operator== (const sub_match< BidirectionalIterator > &left, const sub_match< BidirectionalIterator > &right)

template<class BidirectionalIterator >
bool	operator!= (const sub_match< BidirectionalIterator > &left, const sub_match< BidirectionalIterator > &right)

template<class BidirectionalIterator >
bool	operator< (const sub_match< BidirectionalIterator > &left, const sub_match< BidirectionalIterator > &right)

template<class BidirectionalIterator >
bool	operator> (const sub_match< BidirectionalIterator > &left, const sub_match< BidirectionalIterator > &right)

template<class BidirectionalIterator >
bool	operator<= (const sub_match< BidirectionalIterator > &left, const sub_match< BidirectionalIterator > &right)

template<class BidirectionalIterator >
bool	operator>= (const sub_match< BidirectionalIterator > &left, const sub_match< BidirectionalIterator > &right)

template<class BidirectionalIterator >
bool	operator== (const AZ_REGEX_VALT(BidirectionalIterator) *left, const sub_match< BidirectionalIterator > &right)

template<class BidirectionalIterator >
bool	operator!= (const AZ_REGEX_VALT(BidirectionalIterator) *left, const sub_match< BidirectionalIterator > &right)

template<class BidirectionalIterator >
bool	operator< (const AZ_REGEX_VALT(BidirectionalIterator) *left, const sub_match< BidirectionalIterator > &right)

template<class BidirectionalIterator >
bool	operator> (const AZ_REGEX_VALT(BidirectionalIterator) *left, const sub_match< BidirectionalIterator > &right)

template<class BidirectionalIterator >
bool	operator<= (const AZ_REGEX_VALT(BidirectionalIterator) *left, const sub_match< BidirectionalIterator > &right)

template<class BidirectionalIterator >
bool	operator>= (const AZ_REGEX_VALT(BidirectionalIterator) *left, const sub_match< BidirectionalIterator > &right)

template<class BidirectionalIterator >
bool	operator== (const sub_match< BidirectionalIterator > &left, const AZ_REGEX_VALT(BidirectionalIterator) *right)

template<class BidirectionalIterator >
bool	operator!= (const sub_match< BidirectionalIterator > &left, const AZ_REGEX_VALT(BidirectionalIterator) *right)

template<class BidirectionalIterator >
bool	operator< (const sub_match< BidirectionalIterator > &left, const AZ_REGEX_VALT(BidirectionalIterator) *right)

template<class BidirectionalIterator >
bool	operator> (const sub_match< BidirectionalIterator > &left, const AZ_REGEX_VALT(BidirectionalIterator) *right)

template<class BidirectionalIterator >
bool	operator<= (const sub_match< BidirectionalIterator > &left, const AZ_REGEX_VALT(BidirectionalIterator) *right)

template<class BidirectionalIterator >
bool	operator>= (const sub_match< BidirectionalIterator > &left, const AZ_REGEX_VALT(BidirectionalIterator) *right)

template<class BidirectionalIterator >
bool	operator== (const AZ_REGEX_VALT(BidirectionalIterator)&left, const sub_match< BidirectionalIterator > &right)

template<class BidirectionalIterator >
bool	operator!= (const AZ_REGEX_VALT(BidirectionalIterator)&left, const sub_match< BidirectionalIterator > &right)

template<class BidirectionalIterator >
bool	operator< (const AZ_REGEX_VALT(BidirectionalIterator)&left, const sub_match< BidirectionalIterator > &right)

template<class BidirectionalIterator >
bool	operator> (const AZ_REGEX_VALT(BidirectionalIterator)&left, const sub_match< BidirectionalIterator > &right)

template<class BidirectionalIterator >
bool	operator<= (const AZ_REGEX_VALT(BidirectionalIterator)&left, const sub_match< BidirectionalIterator > &right)

template<class BidirectionalIterator >
bool	operator>= (const AZ_REGEX_VALT(BidirectionalIterator)&left, const sub_match< BidirectionalIterator > &right)

template<class BidirectionalIterator >
bool	operator== (const sub_match< BidirectionalIterator > &left, const AZ_REGEX_VALT(BidirectionalIterator)&right)

template<class BidirectionalIterator >
bool	operator!= (const sub_match< BidirectionalIterator > &left, const AZ_REGEX_VALT(BidirectionalIterator)&right)

template<class BidirectionalIterator >
bool	operator< (const sub_match< BidirectionalIterator > &left, const AZ_REGEX_VALT(BidirectionalIterator)&right)

template<class BidirectionalIterator >
bool	operator> (const sub_match< BidirectionalIterator > &left, const AZ_REGEX_VALT(BidirectionalIterator)&right)

template<class BidirectionalIterator >
bool	operator<= (const sub_match< BidirectionalIterator > &left, const AZ_REGEX_VALT(BidirectionalIterator)&right)

template<class BidirectionalIterator >
bool	operator>= (const sub_match< BidirectionalIterator > &left, const AZ_REGEX_VALT(BidirectionalIterator)&right)

template<class BidirectionalIterator , class Traits , class Allocator >
bool	operator== (const sub_match< BidirectionalIterator > &left, const basic_string< AZ_REGEX_VALT(BidirectionalIterator), Traits, Allocator > &right)

template<class BidirectionalIterator , class Traits , class Allocator >
bool	operator!= (const sub_match< BidirectionalIterator > &left, const basic_string< AZ_REGEX_VALT(BidirectionalIterator), Traits, Allocator > &right)

template<class BidirectionalIterator , class Traits , class Allocator >
bool	operator< (const sub_match< BidirectionalIterator > &left, const basic_string< AZ_REGEX_VALT(BidirectionalIterator), Traits, Allocator > &right)

template<class BidirectionalIterator , class Traits , class Allocator >
bool	operator> (const sub_match< BidirectionalIterator > &left, const basic_string< AZ_REGEX_VALT(BidirectionalIterator), Traits, Allocator > &right)

template<class BidirectionalIterator , class Traits , class Allocator >
bool	operator<= (const sub_match< BidirectionalIterator > &left, const basic_string< AZ_REGEX_VALT(BidirectionalIterator), Traits, Allocator > &right)

template<class BidirectionalIterator , class Traits , class Allocator >
bool	operator>= (const sub_match< BidirectionalIterator > &left, const basic_string< AZ_REGEX_VALT(BidirectionalIterator), Traits, Allocator > &right)

template<class BidirectionalIterator , class Traits , class Allocator >
bool	operator== (const basic_string< AZ_REGEX_VALT(BidirectionalIterator), Traits, Allocator > &left, const sub_match< BidirectionalIterator > &right)

template<class BidirectionalIterator , class Traits , class Allocator >
bool	operator!= (const basic_string< AZ_REGEX_VALT(BidirectionalIterator), Traits, Allocator > &left, const sub_match< BidirectionalIterator > &right)

template<class BidirectionalIterator , class Traits , class Allocator >
bool	operator< (const basic_string< AZ_REGEX_VALT(BidirectionalIterator), Traits, Allocator > &left, const sub_match< BidirectionalIterator > &right)

template<class BidirectionalIterator , class Traits , class Allocator >
bool	operator> (const basic_string< AZ_REGEX_VALT(BidirectionalIterator), Traits, Allocator > &left, const sub_match< BidirectionalIterator > &right)

template<class BidirectionalIterator , class Traits , class Allocator >
bool	operator<= (const basic_string< AZ_REGEX_VALT(BidirectionalIterator), Traits, Allocator > &left, const sub_match< BidirectionalIterator > &right)

template<class BidirectionalIterator , class Traits , class Allocator >
bool	operator>= (const basic_string< AZ_REGEX_VALT(BidirectionalIterator), Traits, Allocator > &left, const sub_match< BidirectionalIterator > &right)

template<class BidirectionalIterator , class Allocator , class InputIterator , class OutputIterator >
OutputIterator	FormatDefault (const match_results< BidirectionalIterator, Allocator > &match, OutputIterator output, InputIterator first, InputIterator last, regex_constants::match_flag_type flags=regex_constants::format_default)

template<class BidirectionalIterator , class Allocator , class InputIterator , class OutputIterator >
OutputIterator	FormatSed (const match_results< BidirectionalIterator, Allocator > &match, OutputIterator output, InputIterator first, InputIterator last, regex_constants::match_flag_type flags=regex_constants::format_default)

template<class BidirectionalIterator , class Allocator >
bool	operator== (const match_results< BidirectionalIterator, Allocator > &left, const match_results< BidirectionalIterator, Allocator > &right)

template<class BidirectionalIterator , class Allocator >
bool	operator!= (const match_results< BidirectionalIterator, Allocator > &left, const match_results< BidirectionalIterator, Allocator > &right)

NodeFlags	operator\| (NodeFlags left, NodeFlags right)

NodeFlags	operator\|= (NodeFlags &left, NodeFlags right)

NodeFlags	operator^= (NodeFlags &left, NodeFlags right)

void	DestroyNode (NodeBase node, NodeBase end=nullptr)

template<class ForwardIt >
	basic_regex (ForwardIt, ForwardIt, AZStd::regex_constants::syntax_option_type=AZStd::regex_constants::ECMAScript) -> basic_regex< typename iterator_traits< ForwardIt >::value_type >

template<class Element , class RegExTraits >
void	swap (basic_regex< Element, RegExTraits > &left, basic_regex< Element, RegExTraits > &right)

template<class BidirectionalIterator , class Allocator >
void	swap (match_results< BidirectionalIterator, Allocator > &left, match_results< BidirectionalIterator, Allocator > &right) AZSTD_THROW0()

template<class BidirectionalIterator , class Allocator , class Element , class RegExTraits , class Iterator >
bool	RegexMatch (Iterator first, Iterator last, match_results< BidirectionalIterator, Allocator > *m_matches, const basic_regex< Element, RegExTraits > &regEx, regex_constants::match_flag_type flags, bool isFull)

template<class BidirectionalIterator , class Allocator , class Element , class RegExTraits >
bool	regex_match (BidirectionalIterator first, BidirectionalIterator last, match_results< BidirectionalIterator, Allocator > &m_matches, const basic_regex< Element, RegExTraits > &regEx, regex_constants::match_flag_type flags=regex_constants::match_default)

template<class BidirectionalIterator , class Element , class RegExTraits >
bool	regex_match (BidirectionalIterator first, BidirectionalIterator last, const basic_regex< Element, RegExTraits > &regEx, regex_constants::match_flag_type flags=regex_constants::match_default)

template<class Element , class RegExTraits >
bool	regex_match (const Element *string, const basic_regex< Element, RegExTraits > &regEx, regex_constants::match_flag_type flags=regex_constants::match_default)

template<class Element , class Allocator , class RegExTraits >
bool	regex_match (const Element string, match_results< const Element , Allocator > &m_matches, const basic_regex< Element, RegExTraits > &regEx, regex_constants::match_flag_type flags=regex_constants::match_default)

template<class _StTraits , class _StAlloc , class Allocator , class Element , class RegExTraits >
bool	regex_match (const basic_string< Element, _StTraits, _StAlloc > &string, match_results< typename basic_string< Element, _StTraits, _StAlloc >::const_iterator, Allocator > &m_matches, const basic_regex< Element, RegExTraits > &regEx, regex_constants::match_flag_type flags=regex_constants::match_default)

template<class _StTraits , class _StAlloc , class Element , class RegExTraits >
bool	regex_match (const basic_string< Element, _StTraits, _StAlloc > &string, const basic_regex< Element, RegExTraits > &regEx, regex_constants::match_flag_type flags=regex_constants::match_default)

template<class BidirectionalIterator , class Allocator , class Element , class RegExTraits , class Iterator >
bool	_Regex_search (Iterator first, Iterator last, match_results< BidirectionalIterator, Allocator > *m_matches, const basic_regex< Element, RegExTraits > &regEx, regex_constants::match_flag_type flags, Iterator original)

template<class BidirectionalIterator , class Allocator , class Element , class RegExTraits >
bool	regex_search (BidirectionalIterator first, BidirectionalIterator last, match_results< BidirectionalIterator, Allocator > &m_matches, const basic_regex< Element, RegExTraits > &regEx, regex_constants::match_flag_type flags=regex_constants::match_default)

template<class BidirectionalIterator , class Element , class RegExTraits >
bool	regex_search (BidirectionalIterator first, BidirectionalIterator last, const basic_regex< Element, RegExTraits > &regEx, regex_constants::match_flag_type flags=regex_constants::match_default)

template<class Element , class RegExTraits >
bool	regex_search (const Element *string, const basic_regex< Element, RegExTraits > &regEx, regex_constants::match_flag_type flags=regex_constants::match_default)

template<class Element , class Allocator , class RegExTraits >
bool	regex_search (const Element string, match_results< const Element , Allocator > &m_matches, const basic_regex< Element, RegExTraits > &regEx, regex_constants::match_flag_type flags=regex_constants::match_default)

template<class _StTraits , class _StAlloc , class Allocator , class Element , class RegExTraits >
bool	regex_search (const basic_string< Element, _StTraits, _StAlloc > &string, match_results< typename basic_string< Element, _StTraits, _StAlloc >::const_iterator, Allocator > &m_matches, const basic_regex< Element, RegExTraits > &regEx, regex_constants::match_flag_type flags=regex_constants::match_default)

template<class _StTraits , class _StAlloc , class Element , class RegExTraits >
bool	regex_search (const basic_string< Element, _StTraits, _StAlloc > &string, const basic_regex< Element, RegExTraits > &regEx, regex_constants::match_flag_type flags=regex_constants::match_default)

template<class OutputIterator , class BidirectionalIterator , class RegExTraits , class Element , class Traits , class Allocator >
OutputIterator	_Regex_replace (OutputIterator _Result, BidirectionalIterator first, BidirectionalIterator last, const basic_regex< Element, RegExTraits > &regEx, const basic_string< Element, Traits, Allocator > &format, regex_constants::match_flag_type flags)

template<class OutputIterator , class BidirectionalIterator , class RegExTraits , class Element , class Traits , class Allocator >
OutputIterator	regex_replace (OutputIterator result, BidirectionalIterator first, BidirectionalIterator last, const basic_regex< Element, RegExTraits > &regEx, const basic_string< Element, Traits, Allocator > &format, regex_constants::match_flag_type flags=regex_constants::match_default)

template<class OutputIterator , class BidirectionalIterator , class RegExTraits , class Element >
OutputIterator	regex_replace (OutputIterator _Result, BidirectionalIterator first, BidirectionalIterator last, const basic_regex< Element, RegExTraits > &regEx, const Element *element, regex_constants::match_flag_type flags=regex_constants::match_default)

template<class RegExTraits , class Element , class _Traits1 , class _Alloc1 , class _Traits2 , class _Alloc2 >
basic_string< Element, _Traits1, _Alloc1 >	regex_replace (const basic_string< Element, _Traits1, _Alloc1 > &string, const basic_regex< Element, RegExTraits > &regEx, const basic_string< Element, _Traits2, _Alloc2 > &format, regex_constants::match_flag_type flags=regex_constants::match_default)

template<class RegExTraits , class Element , class _Traits1 , class _Alloc1 >
basic_string< Element, _Traits1, _Alloc1 >	regex_replace (const basic_string< Element, _Traits1, _Alloc1 > &string, const basic_regex< Element, RegExTraits > &regEx, const Element *element, regex_constants::match_flag_type flags=regex_constants::match_default)

template<class RegExTraits , class Element , class _Traits2 , class _Alloc2 >
basic_string< Element >	regex_replace (const Element *_Pstr, const basic_regex< Element, RegExTraits > &regEx, const basic_string< Element, _Traits2, _Alloc2 > &format, regex_constants::match_flag_type flags=regex_constants::match_default)

template<class RegExTraits , class Element >
basic_string< Element >	regex_replace (const Element _Pstr, const basic_regex< Element, RegExTraits > &regEx, const Element element, regex_constants::match_flag_type flags=regex_constants::match_default)

AZ_FORCE_INLINE bool	IsGreaterEqualToZero (char ch)

AZ_FORCE_INLINE bool	IsGreaterEqualToZero (wchar_t ch)

template<class _BidIt1 , class _BidIt2 , class Predicate >
_BidIt1	_Cmp_chrange (_BidIt1 _Begin1, _BidIt1 _End1, _BidIt2 _Begin2, _BidIt2 _End2, Predicate pred, bool _Partial)

template<class _BidIt1 , class _BidIt2 , class RegExTraits >
_BidIt1	_Compare (_BidIt1 _Begin1, _BidIt1 _End1, _BidIt2 _Begin2, _BidIt2 _End2, const RegExTraits &m_traits, regex_constants::syntax_option_type sflags, bool _Partial)

template<class Element >
bool	_Lookup_range (Element ch, const RegExBuffer< Element > *_Bufptr)

template<class Element , class RegExTraits >
bool	_Lookup_equiv (Element ch, const RegExSequence< Element > *_Eq, const RegExTraits &m_traits)

template<class BidirectionalIterator , class Element >
BidirectionalIterator	_Lookup_coll (BidirectionalIterator first, BidirectionalIterator last, const RegExSequence< Element > *_Eq)

template<class InputIt , class Alloc = allocator>
	basic_string (InputIt, InputIt, Alloc=Alloc()) -> basic_string< iter_value_t< InputIt >, AZStd::char_traits< iter_value_t< InputIt > >, Alloc >

template<class R , class Alloc = allocator, class = enable_if_t<ranges::input_range<R>>>
	basic_string (from_range_t, R &&, Alloc=Alloc()) -> basic_string< ranges::range_value_t< R >, char_traits< ranges::range_value_t< R > >, Alloc >

template<class CharT , class Traits , class Alloc = allocator>
	basic_string (AZStd::basic_string_view< CharT, Traits >, const Alloc &=Alloc()) -> basic_string< CharT, Traits, Alloc >

template<class CharT , class Traits , class Alloc = allocator>
	basic_string (AZStd::basic_string_view< CharT, Traits >, typename allocator_traits< Alloc >::size_type, typename allocator_traits< Alloc >::size_type, const Alloc &=Alloc()) -> basic_string< CharT, Traits, Alloc >

template<class Element , class Traits , class Allocator >
void	swap (basic_string< Element, Traits, Allocator > &left, basic_string< Element, Traits, Allocator > &right)

template<class Element , class Traits , class Allocator >
basic_string< Element, Traits, Allocator >	operator+ (const basic_string< Element, Traits, Allocator > &lhs, const basic_string< Element, Traits, Allocator > &rhs)

template<class Element , class Traits , class Allocator >
basic_string< Element, Traits, Allocator >	operator+ (const Element *lhs, const basic_string< Element, Traits, Allocator > &rhs)

template<class Element , class Traits , class Allocator >
basic_string< Element, Traits, Allocator >	operator+ (Element lhs, const basic_string< Element, Traits, Allocator > &rhs)

template<class Element , class Traits , class Allocator >
basic_string< Element, Traits, Allocator >	operator+ (const basic_string< Element, Traits, Allocator > &lhs, const Element *rhs)

template<class Element , class Traits , class Allocator >
basic_string< Element, Traits, Allocator >	operator+ (const basic_string< Element, Traits, Allocator > &lhs, Element rhs)

template<class Element , class Traits , class Allocator >
bool	operator== (const basic_string< Element, Traits, Allocator > &lhs, const basic_string< Element, Traits, Allocator > &rhs)

template<class Element , class Traits , class Allocator >
bool	operator== (const Element *lhs, const basic_string< Element, Traits, Allocator > &rhs)

template<class Element , class Traits , class Allocator >
bool	operator== (const basic_string< Element, Traits, Allocator > &lhs, const Element *rhs)

template<class Element , class Traits , class Allocator >
bool	operator!= (const basic_string< Element, Traits, Allocator > &lhs, const basic_string< Element, Traits, Allocator > &rhs)

template<class Element , class Traits , class Allocator >
bool	operator!= (const Element *lhs, const basic_string< Element, Traits, Allocator > &rhs)

template<class Element , class Traits , class Allocator >
bool	operator!= (const basic_string< Element, Traits, Allocator > &lhs, const Element *rhs)

template<class Element , class Traits , class Allocator >
bool	operator< (const basic_string< Element, Traits, Allocator > &lhs, const basic_string< Element, Traits, Allocator > &rhs)

template<class Element , class Traits , class Allocator >
bool	operator< (const basic_string< Element, Traits, Allocator > &lhs, const Element *rhs)

template<class Element , class Traits , class Allocator >
bool	operator< (const Element *lhs, const basic_string< Element, Traits, Allocator > &rhs)

template<class Element , class Traits , class Allocator >
bool	operator> (const basic_string< Element, Traits, Allocator > &lhs, const basic_string< Element, Traits, Allocator > &rhs)

template<class Element , class Traits , class Allocator >
bool	operator> (const basic_string< Element, Traits, Allocator > &lhs, const Element *rhs)

template<class Element , class Traits , class Allocator >
bool	operator> (const Element *lhs, const basic_string< Element, Traits, Allocator > &rhs)

template<class Element , class Traits , class Allocator >
bool	operator<= (const basic_string< Element, Traits, Allocator > &lhs, const basic_string< Element, Traits, Allocator > &rhs)

template<class Element , class Traits , class Allocator >
bool	operator<= (const basic_string< Element, Traits, Allocator > &lhs, const Element *rhs)

template<class Element , class Traits , class Allocator >
bool	operator<= (const Element *lhs, const basic_string< Element, Traits, Allocator > &rhs)

template<class Element , class Traits , class Allocator >
bool	operator>= (const basic_string< Element, Traits, Allocator > &lhs, const basic_string< Element, Traits, Allocator > &rhs)

template<class Element , class Traits , class Allocator >
bool	operator>= (const basic_string< Element, Traits, Allocator > &lhs, const Element *rhs)

template<class Element , class Traits , class Allocator >
bool	operator>= (const Element *lhs, const basic_string< Element, Traits, Allocator > &rhs)

template<class Element , class Traits , class Allocator , class U >
decltype(auto)	erase (basic_string< Element, Traits, Allocator > &container, const U &element)

template<class Element , class Traits , class Allocator , class Predicate >
decltype(auto)	erase_if (basic_string< Element, Traits, Allocator > &container, Predicate predicate)

template<class It , class End >
	basic_string_view (It, End) -> basic_string_view< iter_value_t< It > >

template<class R >
	basic_string_view (R &&) -> basic_string_view< ranges::range_value_t< R > >

template<class RandomAccessIterator >
constexpr size_t	hash_string (RandomAccessIterator first, size_t length)
	For string hashing we are using FNV-1a algorithm 64 bit version.

template<class S >
void	tokenize (const S &str, const S &delimiters, vector< S > &tokens)

template<class S >
void	tokenize_keep_empty (const S &str, const S &delimiters, vector< S > &tokens)

template<typename BinaryOp >
constexpr bool	wildcard_match (AZStd::string_view filter, AZStd::string_view name, BinaryOp binaryOp)

constexpr bool	wildcard_match (AZStd::string_view filter, AZStd::string_view name)

constexpr bool	wildcard_match_case (AZStd::string_view filter, AZStd::string_view name)

AZCORE_API AZStd::sys_time_t	GetTimeTicksPerSecond ()

AZCORE_API AZStd::sys_time_t	GetTimeNowTicks ()

AZCORE_API AZStd::sys_time_t	GetTimeNowMicroSecond ()

AZCORE_API AZStd::sys_time_t	GetTimeNowSecond ()

AZCORE_API AZ::u64	GetTimeUTCMilliSecond ()

AZCORE_API AZ::u64	GetTimeUTCMicroSecond ()

AZCORE_API AZStd::chrono::microseconds	GetCpuThreadTimeNowMicrosecond ()

template<class... Types>
auto	swap (const tuple< Types... > &left, const tuple< Types... > &right) -> enable_if_t<(is_swappable_v< const Types > &&...)>

template<class Fn , class Tuple >
constexpr auto	apply (Fn &&f, Tuple &&tupleObj) -> decltype(Internal::apply_impl(AZStd::declval< Fn >(), AZStd::declval< Tuple >(), AZStd::make_index_sequence< AZStd::tuple_size< AZStd::decay_t< Tuple > >::value >{}))

template<class E >
	unexpected (E) -> unexpected< E >

template<class E , class E2 >
constexpr bool	operator== (const unexpected< E > &x, const unexpected< E2 > &y)

template<class E , class E2 >
constexpr bool	operator!= (const unexpected< E > &x, const unexpected< E2 > &y)

template<class E >
constexpr void	swap (unexpected< E > &x, unexpected< E > &y) noexcept(noexcept(x.swap(y)))

template<class T >
constexpr AZStd::remove_reference_t< T > &&	move (T &&t)

template<size_t I, class T1 , class T2 >
constexpr tuple_element_t< I, pair< T1, T2 > > &	get (pair< T1, T2 > &pairObj)

template<size_t I, class T1 , class T2 >
constexpr const tuple_element_t< I, pair< T1, T2 > > &	get (const pair< T1, T2 > &pairObj)

template<size_t I, class T1 , class T2 >
constexpr tuple_element_t< I, pair< T1, T2 > > &&	get (pair< T1, T2 > &&pairObj)

template<size_t I, class T1 , class T2 >
constexpr const tuple_element_t< I, pair< T1, T2 > > &&	get (const pair< T1, T2 > &&pairObj)

template<class T , class U >
constexpr T &	get (pair< T, U > &pairObj)

template<class T , class U >
constexpr T &	get (pair< U, T > &pairObj)

template<class T , class U >
constexpr const T &	get (const pair< T, U > &pairObj)

template<class T , class U >
constexpr const T &	get (const pair< U, T > &pairObj)

template<class T , class U >
constexpr T &&	get (pair< T, U > &&pairObj)

template<class T , class U >
constexpr T &&	get (pair< U, T > &&pairObj)

template<class T , class U >
constexpr const T &&	get (const pair< T, U > &&pairObj)

template<class T , class U >
constexpr const T &&	get (const pair< U, T > &&pairObj)

template<class T1 , class T2 >
	pair (T1, T2) -> pair< T1, T2 >

template<class T1 , class T2 >
constexpr auto	swap (AZStd::pair< T1, T2 > &left, AZStd::pair< T1, T2 > &right) -> enable_if_t< is_swappable_v< T1 > &&is_swappable_v< T2 > >

template<class T1 , class T2 >
constexpr auto	swap (const AZStd::pair< T1, T2 > &left, const AZStd::pair< T1, T2 > &right) -> enable_if_t< is_swappable_v< const T1 > &&is_swappable_v< const T2 > >

template<class L1 , class L2 , class R1 , class R2 , class = AZStd::void_t<decltype(declval<L1>() == declval<R1>() && declval<L2>() == declval<R2>())>>
constexpr bool	operator== (const pair< L1, L2 > &left, const pair< R1, R2 > &right)

template<class L1 , class L2 , class R1 , class R2 , class = AZStd::void_t<decltype(declval<L1>() == declval<R1>() && declval<L2>() == declval<R2>())>>
constexpr bool	operator!= (const pair< L1, L2 > &left, const pair< R1, R2 > &right)

template<class L1 , class L2 , class R1 , class R2 , class = AZStd::void_t<decltype(declval<L1>() < declval<R1>() \|\| (!(declval<R1>() < declval<L1>()) && declval<L2>() < declval<R2>()))>>
constexpr bool	operator< (const pair< L1, L2 > &left, const pair< R1, R2 > &right)

template<class L1 , class L2 , class R1 , class R2 , class = AZStd::void_t<decltype(declval<L1>() < declval<R1>() \|\| (!(declval<R1>() < declval<L1>()) && declval<L2>() < declval<R2>()))>>
constexpr bool	operator> (const pair< L1, L2 > &left, const pair< R1, R2 > &right)

template<class L1 , class L2 , class R1 , class R2 , class = AZStd::void_t<decltype(declval<L1>() < declval<R1>() \|\| (!(declval<R1>() < declval<L1>()) && declval<L2>() < declval<R2>()))>>
constexpr bool	operator<= (const pair< L1, L2 > &left, const pair< R1, R2 > &right)

template<class L1 , class L2 , class R1 , class R2 , class = AZStd::void_t<decltype(declval<L1>() < declval<R1>() \|\| (!(declval<R1>() < declval<L1>()) && declval<L2>() < declval<R2>()))>>
constexpr bool	operator>= (const pair< L1, L2 > &left, const pair< R1, R2 > &right)

template<class T1 , class T2 >
constexpr auto	make_pair (T1 &&value1, T2 &&value2)

template<size_t I, class T1 , class T2 >
constexpr AZStd::tuple_element_t< I, AZStd::pair< T1, T2 > > &	get (AZStd::pair< T1, T2 > &pairObj)

template<size_t I, class T1 , class T2 >
constexpr const AZStd::tuple_element_t< I, AZStd::pair< T1, T2 > > &	get (const AZStd::pair< T1, T2 > &pairObj)

template<size_t I, class T1 , class T2 >
constexpr AZStd::tuple_element_t< I, AZStd::pair< T1, T2 > > &&	get (AZStd::pair< T1, T2 > &&pairObj)

template<size_t I, class T1 , class T2 >
constexpr const AZStd::tuple_element_t< I, AZStd::pair< T1, T2 > > &&	get (const AZStd::pair< T1, T2 > &&pairObj)

template<class Enum >
constexpr AZStd::underlying_type_t< Enum >	to_underlying (Enum value) noexcept

template<class ForwardIterator1 , class ForwardIterator2 >
AZ_FORCE_INLINE void	iter_swap (ForwardIterator1 a, ForwardIterator2 b)

template<class ForwardIterator1 , class ForwardIterator2 >
AZ_FORCE_INLINE ForwardIterator2	swap_ranges (ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2)

template<class T >
constexpr T *	get_pointer (reference_wrapper< T > const &r)

template<class T >
constexpr T *	get_pointer (T *p)

Variables
static constexpr const char *	s_variantTypeId { "{1E8BB1E5-410A-4367-8FAA-D43A4DE14D4B}" }

template<class T , class = void>
constexpr bool	HasToString_v = false

template<class T >
constexpr bool	IsOrderedSet_v = AssociativeInternal::IsOrderedSetImpl_v<AZStd::remove_cvref_t<T>>

template<class T >
constexpr bool	IsOrderedMap_v = AssociativeInternal::IsOrderedMapImpl_v<AZStd::remove_cvref_t<T>>

template<class T >
constexpr bool	IsUnorderedSet_v = AssociativeInternal::IsUnorderedSetImpl_v<AZStd::remove_cvref_t<T>>

template<class T >
constexpr bool	IsUnorderedMap_v = AssociativeInternal::IsUnorderedMapImpl_v<AZStd::remove_cvref_t<T>>

const transfer_ownership_t	s_transfer_ownership {}

template<class T >
constexpr bool	is_bind_expression_v = std::is_bind_expression<T>::value

template<class T >
constexpr size_t	is_placeholder_v = is_placeholder<T>::value

constexpr Internal::to_address_fn	to_address {}

template<class T , class U >
constexpr bool	common_with = Internal::common_with_impl<T, U>

template<class Derived , class Base >
constexpr bool	derived_from

template<class T >
constexpr bool	signed_integral = conjunction_v<bool_constant<integral<T>>, is_signed<T>>

template<class T >
constexpr bool	unsigned_integral = conjunction_v<bool_constant<integral<T>>, bool_constant<!signed_integral<T>>>

template<class T >
constexpr bool	equality_comparable = Internal::weakly_equality_comparable_with<T, T>

template<class T , class U >
constexpr bool	equality_comparable_with = Internal::equally_comparable_with_impl<T, U>

template<class T , class U >
constexpr bool	partially_ordered_with = Internal::partially_ordered_with_impl<T, U>

template<class T >
constexpr bool	totally_ordered = equality_comparable<T> && partially_ordered_with<T, T>

template<class T , class U >
constexpr bool	totally_ordered_with = Internal::totally_ordered_with_impl<T, U>

template<class T >
constexpr bool	default_initializable = Internal::default_initializable_impl<T>

template<class T >
constexpr bool	semiregular = conjunction_v<bool_constant<copyable<T>>, bool_constant<default_initializable<T>>>

template<class T >
constexpr bool	regular = conjunction_v<bool_constant<semiregular<T>>, bool_constant<equality_comparable<T>>>

template<class T >
constexpr bool	weakly_incrementable = Internal::weakly_incrementable_impl<T>

template<class T >
constexpr bool	input_or_output_iterator

template<class T >
constexpr bool	incrementable = Internal::incrementable_impl<T>

template<class S , class I >
constexpr bool	sentinel_for

template<class S , class I >
constexpr bool	disable_sized_sentinel_for = false

template<class S , class I >
constexpr bool	sized_sentinel_for = Internal::sized_sentinel_for_impl<S, I>

template<class I >
constexpr bool	input_iterator = Internal::input_iterator_impl<I>

template<class I , class T >
constexpr bool	output_iterator = Internal::output_iterator_impl<I, T>

template<class I >
constexpr bool	forward_iterator = Internal::forward_iterator_impl<I>

template<class I >
constexpr bool	bidirectional_iterator = Internal::bidirectional_iterator_impl<I>

template<class I >
constexpr bool	random_access_iterator = Internal::random_access_iterator_impl<I>

template<class I >
constexpr bool	contiguous_iterator = Internal::contiguous_iterator_impl<I>

template<class I >
constexpr bool	cpp17_iterator = Internal::cpp17_iterator_impl<I>

template<class I >
constexpr bool	cpp17_input_iterator = Internal::cpp17_input_iterator_impl<I>

template<class I >
constexpr bool	cpp17_forward_iterator = Internal::cpp17_forward_iterator_impl<I>

template<class I >
constexpr bool	cpp17_bidirectional_iterator = Internal::cpp17_bidirectional_iterator_impl<I>

template<class I >
constexpr bool	cpp17_random_access_iterator = Internal::cpp17_random_access_iterator_impl<I>

template<class F , class... Args>
constexpr bool	predicate = Internal::predicate_impl<regular_invocable<F, Args...>, F, Args...>

template<class R , class T , class U >
constexpr bool	relation

template<class R , class T , class U >
constexpr bool	equivalence_relation = relation<R, T, U>

template<class R , class T , class U >
constexpr bool	strict_weak_order = relation<R, T, U>

template<class F , class I , class = void>
constexpr bool	indirectly_unary_invocable = false

template<class F , class I >
constexpr bool	indirectly_unary_invocable< F, I, enable_if_t< conjunction_v< bool_constant< indirectly_readable< I > >, bool_constant< copy_constructible< F > >, bool_constant< invocable< F &, iter_value_t< I > & > >, bool_constant< invocable< F &, iter_reference_t< I > > >, bool_constant< invocable< F &, iter_common_reference_t< I > > >, bool_constant< common_reference_with< invoke_result_t< F &, iter_value_t< I > & >, invoke_result_t< F &, iter_reference_t< I > > > > > > > = true

template<class F , class I , class = void>
constexpr bool	indirectly_regular_unary_invocable = false

template<class F , class I >
constexpr bool	indirectly_regular_unary_invocable< F, I, enable_if_t< conjunction_v< bool_constant< indirectly_readable< I > >, bool_constant< copy_constructible< F > >, bool_constant< regular_invocable< F &, iter_value_t< I > & > >, bool_constant< regular_invocable< F &, iter_reference_t< I > > >, bool_constant< regular_invocable< F &, iter_common_reference_t< I > > >, bool_constant< common_reference_with< invoke_result_t< F &, iter_value_t< I > & >, invoke_result_t< F &, iter_reference_t< I > > > > > > > = true

template<class F , class I , class = void>
constexpr bool	indirect_unary_predicate = false

template<class F , class I >
constexpr bool	indirect_unary_predicate< F, I, enable_if_t< conjunction_v< bool_constant< indirectly_readable< I > >, bool_constant< copy_constructible< F > >, bool_constant< predicate< F &, iter_value_t< I > & > >, bool_constant< predicate< F &, iter_reference_t< I > > >, bool_constant< predicate< F &, iter_common_reference_t< I > > > > > > = true

template<class F , class I1 , class I2 , class = void>
constexpr bool	indirect_binary_predicate = false

template<class F , class I1 , class I2 >
constexpr bool	indirect_binary_predicate< F, I1, I2, enable_if_t< conjunction_v< bool_constant< indirectly_readable< I1 > >, bool_constant< indirectly_readable< I2 > >, bool_constant< copy_constructible< F > >, bool_constant< predicate< F &, iter_value_t< I1 > &, iter_value_t< I2 > & > >, bool_constant< predicate< F &, iter_value_t< I1 > &, iter_reference_t< I2 > > >, bool_constant< predicate< F &, iter_reference_t< I1 >, iter_value_t< I2 > & > >, bool_constant< predicate< F &, iter_reference_t< I1 >, iter_reference_t< I2 > > >, bool_constant< predicate< F &, iter_common_reference_t< I1 >, iter_common_reference_t< I2 > > > > > > = true

template<class F , class I1 , class I2 = I1, class = void>
constexpr bool	indirect_equivalence_relation = false

template<class F , class I1 , class I2 >
constexpr bool	indirect_equivalence_relation< F, I1, I2, enable_if_t< conjunction_v< bool_constant< indirectly_readable< I1 > >, bool_constant< indirectly_readable< I2 > >, bool_constant< copy_constructible< F > >, bool_constant< equivalence_relation< F &, iter_value_t< I1 > &, iter_value_t< I2 > & > >, bool_constant< equivalence_relation< F &, iter_value_t< I1 > &, iter_reference_t< I2 > > >, bool_constant< equivalence_relation< F &, iter_reference_t< I1 >, iter_value_t< I2 > & > >, bool_constant< equivalence_relation< F &, iter_reference_t< I1 >, iter_reference_t< I2 > > >, bool_constant< equivalence_relation< F &, iter_common_reference_t< I1 >, iter_common_reference_t< I2 > > > > > > = true

template<class F , class I1 , class I2 = I1, class = void>
constexpr bool	indirect_strict_weak_order = false

template<class F , class I1 , class I2 >
constexpr bool	indirect_strict_weak_order< F, I1, I2, enable_if_t< conjunction_v< bool_constant< indirectly_readable< I1 > >, bool_constant< indirectly_readable< I2 > >, bool_constant< copy_constructible< F > >, bool_constant< strict_weak_order< F &, iter_value_t< I1 > &, iter_value_t< I2 > & > >, bool_constant< strict_weak_order< F &, iter_value_t< I1 > &, iter_reference_t< I2 > > >, bool_constant< strict_weak_order< F &, iter_reference_t< I1 >, iter_value_t< I2 > & > >, bool_constant< strict_weak_order< F &, iter_reference_t< I1 >, iter_reference_t< I2 > > >, bool_constant< strict_weak_order< F &, iter_common_reference_t< I1 >, iter_common_reference_t< I2 > > > > > > = true

template<class LHS , class RHS >
constexpr bool	assignable_from = Internal::assignable_from_impl<LHS, RHS>

template<class T , class... Args>
constexpr bool	constructible_from

template<class T >
constexpr bool	move_constructible

template<class T >
constexpr bool	copy_constructible = Internal::copy_constructible_impl<T>

template<class T >
constexpr bool	copyable = Internal::copyable_impl<T>

template<class T >
constexpr bool	movable = Internal::movable_impl<T>

template<class T , class Allocator , AZStd::size_t NumElementsPerBlock, AZStd::size_t MinMapSize>
constexpr bool	input_or_output_iterator< deque_iterator_impl< T, Allocator, NumElementsPerBlock, MinMapSize > > = true

template<class I >
constexpr bool	input_or_output_iterator< forward_list_iterator< I > > = true

struct AZStd::intrusive_list_node	AZ_MAY_ALIAS

template<class T >
constexpr bool	input_or_output_iterator< list_iterator< T > > = true

constexpr size_t	dynamic_extent = numeric_limits<size_t>::max()

template<class T >
constexpr size_t	variant_size_v = variant_size<T>::value

constexpr size_t	variant_npos = static_cast<size_t>(-1)

static constexpr size_t	not_found = static_cast<size_t>(-1)

static constexpr size_t	ambiguous = not_found - 1

template<typename T , typename... Types>
constexpr size_t	find_exactly_one_alternative_v = find_exactly_one_alternative<T, Types...>::value

template<class Fn , class... ArgTypes>
constexpr bool	is_invocable_v = is_invocable<Fn, ArgTypes...>::value

template<class R , class Fn , class ... ArgTypes>
constexpr bool	is_invocable_r_v = is_invocable_r<R, Fn, ArgTypes...>::value

template<class Fn , class... ArgTypes>
constexpr bool	is_nothrow_invocable_v = is_nothrow_invocable<Fn, ArgTypes...>::value

template<class R , class Fn , class ... ArgTypes>
constexpr bool	is_nothrow_invocable_r_v = is_nothrow_invocable_r<R, Fn, ArgTypes...>::value

template<class F , class... Args>
constexpr bool	invocable = is_invocable_v<F, Args...>

template<class F , class... Args>
constexpr bool	regular_invocable = invocable<F, Args...>

constexpr default_sentinel_t	default_sentinel {}

template<class It >
constexpr bool	not_a_const_iterator = true

template<class It >
constexpr bool	not_a_const_iterator< basic_const_iterator< It > > = Internal::is_primary_template_v<basic_const_iterator<It>>

template<class In >
constexpr bool	indirectly_readable = Internal::indirectly_readable_impl<remove_cvref_t<In>>

template<class Out , class T >
constexpr bool	indirectly_writable = Internal::indirectly_writable_impl<Out, T>

template<class In , class Out >
constexpr bool	indirectly_movable

template<class In , class Out >
constexpr bool	indirectly_movable_storable = Internal::indirectly_movable_storage_impl<In, Out>

template<class In , class Out >
constexpr bool	indirectly_copyable = Internal::indirectly_copyable_impl<In, Out>

template<class In , class Out >
constexpr bool	indirectly_copyable_storable = Internal::indirectly_copyable_storable_impl<In, Out>

constexpr unreachable_sentinel_t	unreachable_sentinel {}

constexpr defer_lock_t	defer_lock {}

constexpr try_to_lock_t	try_to_lock {}

constexpr adopt_lock_t	adopt_lock {}

constexpr from_range_t	from_range

template<class I1 , class I2 , class R , class P1 = identity, class P2 = identity, class = void>
constexpr bool	indirectly_comparable = false

template<class I1 , class I2 , class R , class P1 , class P2 >
constexpr bool	indirectly_comparable< I1, I2, R, P1, P2, enable_if_t< indirect_binary_predicate< R, projected< I1, P1 >, projected< I2, P2 > > > > = true

template<class I , class = void>
constexpr bool	permutable = false

template<class I >
constexpr bool	permutable< I, enable_if_t< conjunction_v< bool_constant< forward_iterator< I > >, bool_constant< indirectly_movable_storable< I, I > >, bool_constant< indirectly_swappable< I, I > > > > > = true

template<class I1 , class I2 , class Out , class R = ranges::less, class P1 = identity, class P2 = identity, class = void>
constexpr bool	mergeable = false

template<class I1 , class I2 , class Out , class R , class P1 , class P2 >
constexpr bool	mergeable< I1, I2, Out, R, P1, P2, enable_if_t< conjunction_v< bool_constant< input_iterator< I1 > >, bool_constant< input_iterator< I2 > >, bool_constant< weakly_incrementable< Out > >, bool_constant< indirectly_copyable< I1, Out > >, bool_constant< indirectly_copyable< I2, Out > >, bool_constant< indirect_strict_weak_order< R, projected< I1, P1 >, projected< I2, P2 > > > > > > = true

template<class I , class R = ranges::less, class P = identity, class = void>
constexpr bool	sortable = false

template<class I , class R , class P >
constexpr bool	sortable< I, R, P, enable_if_t< conjunction_v< bool_constant< permutable< I > >, bool_constant< indirect_strict_weak_order< R, projected< I, P > > > > > > = true

template<class T >
constexpr bool	swappable = Internal::swappable_impl<T>

template<class T , class U >
constexpr bool	swappable_with = Internal::swappable_with_impl<T, U>

template class AZCORE_API	intrusive_refcount< atomic_uint >

const int	AZSTD_MAX_INSERTION_SORT_SIZE = 32

template class AZCORE_API	basic_fixed_string< char, 1024 >

template struct AZCORE_API	ClassNames< char >

template struct AZCORE_API	ClassNames< wchar_t >

template class AZCORE_API	RegexTraits< char >

template class AZCORE_API	RegexTraits< wchar_t >

const int	NFA_BRE_MAX_GRP = 9

const int	BITMAP_max = 256

const int	BITMAP_shift = 3

const int	BITMAP_chrs = 1 << BITMAP_shift

const int	BITMAP_mask = BITMAP_chrs - 1

const int	BITMAP_size = (BITMAP_max + BITMAP_chrs - 1) / BITMAP_chrs

const int	BUFFER_INCREMENT = 16

const int	BITMAP_ARRAY_THRESHOLD = 4

static const unsigned int	_ECMA_flags

static const unsigned int	_Basic_flags

static const unsigned int	_Grep_flags = _Basic_flags \| LF_alt_nl \| LF_no_nl

static const unsigned int	_Extended_flags

static const unsigned int	_Awk_flags = _Extended_flags \| LF_esc_oct \| LF_esc_ffn \| LF_esc_ffnx \| LF_ident_awk

static const unsigned int	_Egrep_flags = _Extended_flags \| LF_alt_nl \| LF_no_nl

static const char	Meta_map []

template<class T , class U >
constexpr bool	common_reference_with = Internal::common_reference_with_impl<T, U>

template<class T >
constexpr bool	is_bounded_array_v = is_bounded_array<T>::value

template<class T >
constexpr bool	is_unbounded_array_v = is_unbounded_array<T>::value

template<class T , class U >
constexpr bool	is_assignable_v = std::is_assignable<T, U>::value

template<class T , class U >
constexpr bool	is_trivially_assignable_v = std::is_trivially_assignable<T, U>::value

template<class T , class U >
constexpr bool	is_nothrow_assignable_v = std::is_nothrow_assignable<T, U>::value

template<class T >
constexpr bool	is_copy_assignable_v = std::is_copy_assignable<T>::value

template<class T >
constexpr bool	is_trivially_copy_assignable_v = std::is_trivially_copy_assignable<T>::value

template<class T >
constexpr bool	is_nothrow_copy_assignable_v = std::is_nothrow_copy_assignable<T>::value

template<class T >
constexpr bool	is_move_assignable_v = std::is_move_assignable<T>::value

template<class T >
constexpr bool	is_trivially_move_assignable_v = std::is_trivially_move_assignable<T>::value

template<class T >
constexpr bool	is_nothrow_move_assignable_v = std::is_nothrow_move_assignable<T>::value

template<class T >
constexpr bool	is_const_v = std::is_const<T>::value

template<typename From , typename To >
constexpr bool	convertible_to = Internal::convertible_to_impl<From, To>

template<class T >
constexpr bool	is_default_destructible_v = std::is_destructible<T>::value

template<class T >
constexpr bool	is_trivially_destructible_v = std::is_trivially_destructible<T>::value

template<class T >
constexpr bool	is_nothrow_destructible_v = std::is_nothrow_destructible<T>::value

template<class T >
constexpr bool	destructible = is_nothrow_destructible_v<T>

template<class T >
constexpr bool	floating_point = is_floating_point_v<T>

template<class T >
constexpr bool	is_function_pointer_v = is_function_pointer<T>::value

template<class T >
constexpr bool	integral = is_integral_v<T>

template<typename T >
constexpr bool	is_pointer_v = std::is_pointer_v<T>

template<typename T >
constexpr bool	is_rvalue_reference_v = std::is_rvalue_reference<T>::value

template<class T , class U >
constexpr bool	same_as = is_same_v<T, U>

template<class T >
constexpr bool	is_volatile_v = std::is_volatile<T>::value

constexpr unexpect_t	unexpect {}

static constexpr piecewise_construct_t	piecewise_construct {}

template<class T >
constexpr bool	tuple_like = Internal::is_tuple_like<remove_cvref_t<T>>

template<class T , class = void>
constexpr bool	pair_like = false

template<class T >
constexpr bool	pair_like< T, enable_if_t< tuple_like< T > > > = tuple_size_v<remove_cvref_t<T>> == 2

static constexpr pthread_t	native_thread_invalid_id = 0

static constexpr pthread_t	native_thread_invalid_id = 0

static constexpr native_thread_id_type	native_thread_invalid_id = 0

static constexpr pthread_t	native_thread_invalid_id = 0

HashFuntions Hash Functions
Follow the standard 20.8.12
template<typename KeyType >
using	HasherInvocable = AZStd::conjunction< AZStd::disjunction< AZStd::negation< HasDefaultHash< hash< KeyType > > >, IsNumber< KeyType >, AZStd::is_enum< KeyType > >, AZStd::is_default_constructible< hash< KeyType > >, AZStd::is_invocable_r< size_t, hash< KeyType >, const KeyType & > >

template<typename... Types>
using	hash_enabled_concept = AZStd::bool_constant< AZStd::conjunction_v< HasherInvocable< Types >... > >

template<typename KeyType >
constexpr bool	HasherInvocable_v = HasherInvocable<KeyType>::value

template<typename... Types>
constexpr bool	hash_enabled_concept_v = hash_enabled_concept<Types...>::value

	AZ_HAS_STATIC_MEMBER (DefaultHash, OnlyUnspecializedTypesShouldHaveThis, bool,())
	define your own struct AZStd::hash<T> and HasherInvocable<T>::type will be AZStd::true_type

template<class T >
constexpr void	hash_combine (AZStd::size_t &seed, T const &v)

template<class T1 , class T2 , class... RestTypes>
constexpr void	hash_combine (AZStd::size_t &seed, const T1 &firstElement, const T2 &secondElement, const RestTypes &... restElements)

template<class It >
constexpr AZStd::size_t	hash_range (It first, It last)

template<class It >
constexpr void	hash_range (AZStd::size_t &seed, It first, It last)

AZCORE_API AZStd::size_t	hash_next_bucket_size (AZStd::size_t n)

Detailed Description

AZ namespace needs to be closed in order to specialize the AZStd::hash struct for AddressTypeElement and AddressType.

Native synchronization types.

Cx11 Regular expressions based on STL from manufacturers. All allocations are piped through the system allocator by default. we don't use std::locale/std::facet/std::collate/etc. as the facets do allocate global memory which is freed atexit(). This of course is not compliant with our allocation schema.

This file is to be included from the semaphore.h only. It should NOT be included by the user.

This file is to be included from the mutex.h only. It should NOT be included by the user.

Typedef Documentation

◆ intrusive_base

using AZStd::intrusive_base = typedef intrusive_refcount<atomic_uint>

An intrusive reference counting base class that is compliant with AZStd::intrusive_ptr. This version is thread-safe through use of an implicit atomic reference count. Explicit friending of intrusive_ptr is used; the user must use intrusive_ptr to take a reference on the object.

Enumeration Type Documentation

◆ cv_status

enum class AZStd::cv_status

strong

Condition variables provide synchronization primitives used to block a thread until notified by some other thread that some condition is met or until a system time is reached. C++11

◆ iterator_status_flag

enum AZStd::iterator_status_flag

Enumerator
isf_none	Iterator is invalid.
isf_valid	Iterator point to a valid element in container, we can't dereference of all them. For instance the end() is a valid iterator, but you can't access it.
isf_can_dereference	We can dereference this iterator (it points to a valid element).

Function Documentation

◆ all_of()

template<class InputIter , class UnaryOperation >

constexpr bool AZStd::all_of	(	InputIter	first,
		InputIter	last,
		UnaryOperation	operation
	)

constexpr

True if operation returns true for all elements in the range. True if range is empty.

◆ alphanum_comp()

template<class Element , class Traits , class Allocator1 , class Allocator2 >

AZ_FORCE_INLINE int AZStd::alphanum_comp	(	const basic_string< Element, Traits, Allocator1 > &	l,
		const basic_string< Element, Traits, Allocator2 > &	r
	)

Compare l and r with the same semantics as strcmp(), but with the "Alphanum Algorithm" which produces more human-friendly results.

Returns: negative if l<r, 0 if l==r, positive if l>r.

◆ any_numeric_cast()

template<typename ValueType , typename = enable_if_t<std::numeric_limits<ValueType>::is_specialized>>

bool AZStd::any_numeric_cast	(	const any *	operand,
		ValueType &	result
	)

Extension: Converts an any to a convertible numeric type (see aznumeric_cast)

Parameters

operand	The any to cast
result	The variable to assign the result into if cast succeeds

Returns: true if conversion is successful, false if unsuccessful

◆ any_of()

template<class InputIter , class UnaryOperation >

constexpr bool AZStd::any_of	(	InputIter	first,
		InputIter	last,
		UnaryOperation	operation
	)

constexpr

True if operation returns true for any element in the range. False if the range is empty.

◆ construct_at()

template<typename T , typename... Args>

constexpr auto AZStd::construct_at	(	T *	ptr,
		Args &&...	args
	)		-> decltype(new (AZStd::declval<void>()) T(AZStd::forward<Args>(args)...), (T)nullptr)

constexpr

C++20 implementation of construct_at Invokes placement new on the supplied address Constraints: Only available when the expression new (declval<void*>()) T(declval<Args>()...) is well-formed

◆ destroy()

template<typename ForwardIt >

constexpr void AZStd::destroy	(	ForwardIt	first,
		ForwardIt	last
	)

constexpr

Implements the C++17 destroy function which works on a range of elements The functions accepts a first and last iterator and invokes the destructor on all element in the iterator range

◆ destroy_at()

template<typename T >

constexpr void AZStd::destroy_at ( T * ptr )

constexpr

Implements the C++20 version of destroy_at If the element type T is not an array type it invokes the destructor on that object Otherwise it recursively destructs the elements of the array as if by calling AZStd::destroy(AZStd::begin(*ptr), AZStd::end(*ptr))

◆ destroy_n()

template<typename ForwardIt , size_t N>

constexpr ForwardIt AZStd::destroy_n	(	ForwardIt	first,
		size_t	numElements
	)

constexpr

Implements the C++17 destroy_n function The function accepts a forward iterator and a number of elements and invokes the destructor on all the elements in the range Returns an iterator past the last element destructed

◆ get() [1/16]

template<size_t I, class T1 , class T2 >

constexpr AZStd::tuple_element_t< I, AZStd::pair< T1, T2 > > && AZStd::get ( AZStd::pair< T1, T2 > && pairObj )

constexpr

Wraps the std::get function in the AZStd namespace This methods retrieves the tuple element at a particular index within the pair

◆ get() [2/16]

template<size_t I, class T1 , class T2 >

constexpr AZStd::tuple_element_t< I, AZStd::pair< T1, T2 > > & AZStd::get ( AZStd::pair< T1, T2 > & pairObj )

constexpr

Wraps the std::get function in the AZStd namespace This methods retrieves the tuple element at a particular index within the pair

◆ get() [3/16]

template<size_t I, class T1 , class T2 >

constexpr const AZStd::tuple_element_t< I, AZStd::pair< T1, T2 > > && AZStd::get ( const AZStd::pair< T1, T2 > && pairObj )

constexpr

Wraps the std::get function in the AZStd namespace This methods retrieves the tuple element at a particular index within the pair

◆ get() [4/16]

template<size_t I, class T1 , class T2 >

constexpr const AZStd::tuple_element_t< I, AZStd::pair< T1, T2 > > & AZStd::get ( const AZStd::pair< T1, T2 > & pairObj )

constexpr

Wraps the std::get function in the AZStd namespace This methods retrieves the tuple element at a particular index within the pair

◆ get() [5/16]

template<class T , class U >

constexpr const T && AZStd::get ( const pair< T, U > && pairObj )

constexpr

Wraps the std::get function in the AZStd namespace This methods extracts an element from the pair with the specified type T If there is more than one T in the pair, then this function fails to compile

◆ get() [6/16]

template<class T , class U >

constexpr const T & AZStd::get ( const pair< T, U > & pairObj )

constexpr

Wraps the std::get function in the AZStd namespace This methods extracts an element from the pair with the specified type T If there is more than one T in the pair, then this function fails to compile

◆ get() [7/16]

template<size_t I, class T1 , class T2 >

constexpr const tuple_element_t< I, pair< T1, T2 > > && AZStd::get ( const AZStd::pair< T1, T2 > && pairObj )

constexpr

Wraps the std::get function in the AZStd namespace This methods retrieves the tuple element at a particular index within the pair

◆ get() [8/16]

template<size_t I, class T1 , class T2 >

constexpr const tuple_element_t< I, pair< T1, T2 > > & AZStd::get ( const AZStd::pair< T1, T2 > & pairObj )

constexpr

Wraps the std::get function in the AZStd namespace This methods retrieves the tuple element at a particular index within the pair

◆ get() [9/16]

template<class T , class U >

constexpr const T && AZStd::get ( const pair< U, T > && pairObj )

constexpr

Wraps the std::get function in the AZStd namespace This methods extracts an element from the pair with the specified type T If there is more than one T in the pair, then this function fails to compile

◆ get() [10/16]

template<class T , class U >

constexpr const T & AZStd::get ( const pair< U, T > & pairObj )

constexpr

Wraps the std::get function in the AZStd namespace This methods extracts an element from the pair with the specified type T If there is more than one T in the pair, then this function fails to compile

◆ get() [11/16]

template<class T , class U >

constexpr T && AZStd::get ( AZStd::pair< T, U > && pairObj )

constexpr

Wraps the std::get function in the AZStd namespace This methods extracts an element from the pair with the specified type T If there is more than one T in the pair, then this function fails to compile

◆ get() [12/16]

template<class T , class U >

constexpr T & AZStd::get ( AZStd::pair< T, U > & pairObj )

constexpr

Wraps the std::get function in the AZStd namespace This methods extracts an element from the pair with the specified type T If there is more than one T in the pair, then this function fails to compile

◆ get() [13/16]

template<size_t I, class T1 , class T2 >

constexpr tuple_element_t< I, pair< T1, T2 > > && AZStd::get ( AZStd::pair< T1, T2 > && pairObj )

constexpr

Wraps the std::get function in the AZStd namespace This methods retrieves the tuple element at a particular index within the pair

◆ get() [14/16]

template<size_t I, class T1 , class T2 >

constexpr tuple_element_t< I, pair< T1, T2 > > & AZStd::get ( AZStd::pair< T1, T2 > & pairObj )

constexpr

Wraps the std::get function in the AZStd namespace This methods retrieves the tuple element at a particular index within the pair

◆ get() [15/16]

template<class T , class U >

constexpr T && AZStd::get ( AZStd::pair< U, T > && pairObj )

constexpr

Wraps the std::get function in the AZStd namespace This methods extracts an element from the pair with the specified type T If there is more than one T in the pair, then this function fails to compile

◆ get() [16/16]

template<class T , class U >

constexpr T & AZStd::get ( AZStd::pair< U, T > & pairObj )

constexpr

Wraps the std::get function in the AZStd namespace This methods extracts an element from the pair with the specified type T If there is more than one T in the pair, then this function fails to compile

◆ GetCpuThreadTimeNowMicrosecond()

AZCORE_API AZStd::chrono::microseconds AZStd::GetCpuThreadTimeNowMicrosecond ( )

Returns the cpu time spent on the current thread when invoked This time is relative to the running process and has no relation to real time

◆ insertion_sort() [1/2]

template<class RandomAccessIterator >

void AZStd::insertion_sort	(	RandomAccessIterator	first,
		RandomAccessIterator	last
	)

insertion_sort using default less predicate. [first, last), using operator<

◆ insertion_sort() [2/2]

template<class RandomAccessIterator , class Compare >

void AZStd::insertion_sort	(	RandomAccessIterator	first,
		RandomAccessIterator	last,
		Compare	comp
	)

insertion_sort using user compare. [first, last)

◆ none_of()

template<class InputIter , class UnaryOperation >

constexpr bool AZStd::none_of	(	InputIter	first,
		InputIter	last,
		UnaryOperation	operation
	)

constexpr

True if operation returns true for no elements in the range. True if range is empty.

◆ operator==() [1/2]

bool AZStd::operator==	(	const function_base &	f,
		Internal::function_util::useless_clear_type *
	)

inline

The bad_function_call exception class is thrown when a AZStd::function object is invoked

◆ operator==() [2/2]

template<typename R , typename... Args>

void AZStd::operator==	(	const function_intermediate< R, Args... > &	,
		const function_intermediate< R, Args... > &
	)

delete

Don't allow comparisons between objects of the same type. Comparing the objects stored within two type erased functions does not have a well define way to determine if both objects are equality comparable This can be illustrated in the following function_intermediate<WellDefinedSignature>(Functor1) == function_intermediate<WellDefinedSignature>(Functor2) The only way an equality comparison can occur is if Functor1 can compare to Functor2 and that information cannot be known by the function class

◆ uninitialized_copy()

template<class InputIterator , class ForwardIterator >

constexpr ForwardIterator AZStd::uninitialized_copy	(	InputIterator	first,
		InputIterator	last,
		ForwardIterator	result,
		bool
	)

constexpr

Specialized algorithms 20.4.4. We extend that by adding faster specialized versions when we have trivial assign type.

◆ uninitialized_move()

template<typename InputIt , typename ForwardIt >

ForwardIt AZStd::uninitialized_move	(	InputIt	first,
		InputIt	last,
		ForwardIt	result
	)

Implements the C++17 uninitialized_move function The functions accepts two input iterators and an output iterator It performs an AZStd::move on each in in the range of the input iterator and stores the result in location pointed by the output iterator

◆ wildcard_match()

template<typename BinaryOp >

constexpr bool AZStd::wildcard_match	(	AZStd::string_view	filter,
		AZStd::string_view	name,
		BinaryOp	binaryOp
	)

constexpr

Wildcard '*' and '?' matching support.

Example: if (wildcard_match("bl?h.*", "blah.jpg")) { we have a match! } else { no match } TODO: wchar_t version

Variable Documentation

◆ _Basic_flags

const unsigned int AZStd::_Basic_flags

static

Initial value:

= LF_bckr | LF_lim_bckr | LF_anch_rstr

| LF_star_beg | LF_empty_grp | LF_brk_rstr | LF_mtch_long

◆ _ECMA_flags

const unsigned int AZStd::_ECMA_flags

static

Initial value:

= LF_ext_rep | LF_alt_pipe | LF_nex_grp | LF_nex_rep | LF_nc_grp
        | LF_asrt_gen | LF_asrt_wrd | LF_bckr | LF_ngr_rep
        | LF_esc_uni | LF_esc_hex | LF_esc_bsl | LF_esc_ffn | LF_esc_wsd
        | LF_esc_ctrl | LF_bzr_chr | LF_grp_esc | LF_ident_ECMA
        | LF_empty_grp

◆ _Extended_flags

const unsigned int AZStd::_Extended_flags

static

Initial value:

= LF_ext_rep | LF_alt_pipe | LF_nex_grp | LF_nex_rep | LF_ident_ERE

| LF_paren_bal | LF_brk_rstr | LF_mtch_long

◆ constructible_from

template<class T , class... Args>

constexpr bool AZStd::constructible_from

constexpr

Initial value:

= conjunction_v<bool_constant<destructible<T>>,

is_constructible<T, Args...> >

◆ derived_from

template<class Derived , class Base >

constexpr bool AZStd::derived_from

constexpr

Initial value:

= conjunction_v<is_base_of<Base, Derived>,

is_convertible<const volatile Derived*, const volatile Base*>>

◆ indirectly_movable

template<class In , class Out >

constexpr bool AZStd::indirectly_movable

constexpr

Initial value:

= conjunction_v<bool_constant<indirectly_readable<In>>,

bool_constant<indirectly_writable<Out, iter_rvalue_reference_t<In>>>>

◆ input_or_output_iterator

template<class T >

constexpr bool AZStd::input_or_output_iterator

constexpr

Initial value:

= conjunction_v<bool_constant<!is_void_v<T>>,

bool_constant<weakly_incrementable<T>>>

◆ Meta_map

const char AZStd::Meta_map[]

static

Initial value:

=
    {   
        Meta_lpar, Meta_rpar, Meta_dlr, Meta_caret,
        Meta_dot, Meta_star, Meta_plus, Meta_query,
        Meta_lsq, Meta_rsq, Meta_bar, Meta_esc,
        Meta_dash, Meta_lbr, Meta_rbr, Meta_comma,
        Meta_colon, Meta_equal, Meta_exc, Meta_nl,
        Meta_cr, Meta_bsp,
        0
    }

◆ move_constructible

template<class T >

constexpr bool AZStd::move_constructible

constexpr

Initial value:

= conjunction_v<bool_constant<constructible_from<T, T>>,

bool_constant<convertible_to<T, T>>>

◆ relation

template<class R , class T , class U >

constexpr bool AZStd::relation

constexpr

Initial value:

= conjunction_v<
        bool_constant<predicate<R, T, T>>,
        bool_constant<predicate<R, U, U>>,
        bool_constant<predicate<R, T, U>>,
        bool_constant<predicate<R, U, T>>>

◆ sentinel_for

template<class S , class I >

constexpr bool AZStd::sentinel_for

constexpr

Initial value:

= conjunction_v<
        bool_constant<semiregular<S>>,
        bool_constant<input_or_output_iterator<I>>,
        bool_constant<Internal::weakly_equality_comparable_with<S, I>>>

Classes

Typedefs

Enumerations

Functions

Variables

HashFuntions Hash Functions

Detailed Description

Typedef Documentation

◆ intrusive_base

Enumeration Type Documentation

◆ cv_status

◆ iterator_status_flag

Function Documentation

◆ all_of()

◆ alphanum_comp()

◆ any_numeric_cast()

◆ any_of()

◆ construct_at()

◆ destroy()

◆ destroy_at()

◆ destroy_n()

◆ get() [1/16]

◆ get() [2/16]

◆ get() [3/16]

◆ get() [4/16]

◆ get() [5/16]

◆ get() [6/16]

◆ get() [7/16]

◆ get() [8/16]

◆ get() [9/16]

◆ get() [10/16]

◆ get() [11/16]

◆ get() [12/16]

◆ get() [13/16]

◆ get() [14/16]

◆ get() [15/16]

◆ get() [16/16]

◆ GetCpuThreadTimeNowMicrosecond()

◆ insertion_sort() [1/2]

◆ insertion_sort() [2/2]

◆ none_of()

◆ operator==() [1/2]

◆ operator==() [2/2]

◆ uninitialized_copy()

◆ uninitialized_move()

◆ wildcard_match()

Variable Documentation

◆ _Basic_flags

◆ _ECMA_flags

◆ _Extended_flags

◆ constructible_from

◆ derived_from

◆ indirectly_movable

◆ input_or_output_iterator

◆ Meta_map

◆ move_constructible

◆ relation

◆ sentinel_for