Open 3D Engine AzCore API Reference  2305.0
O3DE is an open-source, fully-featured, high-fidelity, modular 3D engine for building games and simulations, available to every industry.
Classes | Typedefs | Enumerations | Functions | Variables
AZStd Namespace Reference

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

Classes

struct  hash< AZ::Data::AssetId >
 
class  vector
 
struct  hash< AZ::Data::AssetContainerKey >
 
struct  hash< AZ::EntityComponentIdPair >
 
struct  hash< AZ::EntityId >
 
struct  hash< AZ::NamedEntityId >
 
struct  char_traits
 
class  basic_string_view
 
class  basic_fixed_string
 
class  fixed_vector
 
struct  hash< AZ::Dom::PathEntry >
 
struct  hash< AZ::Dom::Path >
 
struct  hash< AZ::IO::PathView >
 
struct  hash< AZ::IO::BasicPath< StringType > >
 
class  basic_string
 
struct  hash
 Default template (just try to cast the value to size_t) More...
 
struct  hash< AZ::IO::RequestPath >
 
struct  hash< AZ::Crc32 >
 
struct  hash< AZ::Uuid >
 
struct  hash< AZ::Name >
 
struct  hash< AZ::NameRef >
 
class  list
 
class  forward_list
 
class  array
 
class  unordered_map
 
class  unordered_set
 
class  bitset
 
class  intrusive_ptr
 
class  shared_ptr
 
struct  less
 
struct  less_equal
 
struct  greater
 
struct  greater_equal
 
struct  equal_to
 
struct  pair
 
class  map
 
class  unordered_multimap
 
class  set
 
class  unordered_multiset
 
class  fixed_list
 
class  fixed_forward_list
 
class  function
 
class  variant
 
struct  is_type_safe_integral
 
struct  hash< AZ::DataOverlayInstanceId >
 
struct  hash< AZ::DataPatchInternal::AddressTypeElement >
 
struct  hash< AZ::DataPatchInternal::AddressType >
 used for hashing
 
struct  hash< AZ::Data::Asset< AZ::SliceAsset > >
 
struct  hash< AZ::SliceComponent::SliceInstanceAddress >
 
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 >
 
class  allocator
 
class  no_default_allocator
 
class  allocator_ref
 
class  stack_allocator
 
class  stateless_allocator
 
class  static_buffer_allocator
 
class  static_pool_allocator
 
struct  allocator_traits
 
struct  transfer_ownership_t
 distinguishes between any Extension constructor calls More...
 
class  any
 
struct  projected
 
struct  projected< I, Proj, enable_if_t< conjunction_v< bool_constant< indirectly_readable< I > >, bool_constant< indirectly_regular_unary_invocable< Proj, I > > > > >
 
struct  incrementable_traits< projected< I, Proj >, enable_if_t< weakly_incrementable< I > > >
 
class  array< T, 0U >
 
struct  compressed_pair_element
 
struct  compressed_pair_element< T, Index, true >
 
struct  skip_element_tag
 
class  compressed_pair
 
struct  deque_block
 
class  deque
 
class  deque_iterator_impl
 
class  fixed_unordered_map
 
class  fixed_unordered_multimap
 
class  fixed_unordered_set
 
class  fixed_unordered_multiset
 
class  forward_list_iterator
 
struct  intrusive_list_node
 
struct  list_base_hook
 
struct  list_member_hook
 
class  intrusive_list
 
struct  intrusive_multiset_node
 
struct  intrusive_multiset_base_hook
 
struct  intrusive_multiset_member_hook
 
class  intrusive_multiset
 
struct  intrusive_slist_node
 
struct  slist_base_hook
 
struct  slist_member_hook
 
class  intrusive_slist
 
class  list_iterator
 
class  multimap
 
class  rbtree
 
class  hash_table
 
class  rbtree_const_iterator
 
class  rbtree_iterator
 
class  rbtree_node_destructor
 
class  ring_buffer
 
class  multiset
 
class  span
 
struct  monostate
 
struct  hash< monostate >
 
struct  hash< variant< Types...> >
 
struct  variant_size
 
struct  variant_size< variant< Types...> >
 
struct  variant_size< const T >
 
struct  variant_size< volatile T >
 
struct  variant_size< const volatile T >
 
struct  variant_alternative
 
struct  variant_alternative< Index, variant< Types...> >
 
struct  variant_alternative< Index, const T >
 
struct  variant_alternative< Index, volatile T >
 
struct  variant_alternative< Index, const volatile T >
 
class  delegate_memento
 
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  function_base
 
class  function_intermediate
 
class  function< R(Args...)>
 
struct  identity
 
struct  is_invocable
 
struct  is_invocable_r
 
struct  is_nothrow_invocable
 
struct  is_nothrow_invocable_r
 
struct  invoke_result
 
struct  plus
 
struct  plus< void >
 
struct  minus
 
struct  minus< void >
 
struct  multiplies
 
struct  multiplies< void >
 
struct  divides
 
struct  divides< void >
 
struct  modulus
 
struct  modulus< void >
 
struct  negate
 
struct  negate< void >
 
struct  equal_to< void >
 
struct  not_equal_to
 
struct  not_equal_to< void >
 
struct  greater< void >
 
struct  less< void >
 
struct  greater_equal< void >
 
struct  less_equal< void >
 
struct  logical_and
 
struct  logical_and< void >
 
struct  logical_or
 
struct  logical_or< void >
 
struct  logical_not
 
struct  logical_not< void >
 
struct  bit_and
 
struct  bit_and< void >
 
struct  bit_or
 
struct  bit_or< void >
 
struct  bit_xor
 
struct  bit_xor< void >
 
struct  bit_not
 
struct  bit_not< void >
 
struct  IsNumber
 
struct  IsNumber< T, true >
 
struct  hash< const T * >
 
struct  hash< T * >
 
struct  hash< const T[N] >
 
struct  hash< T[N] >
 
struct  hash< float >
 
struct  hash< double >
 
struct  hash< long double >
 
struct  hash< AZStd::pair< T, U > >
 
class  hash_node_destructor
 
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  incrementable_traits< common_iterator< I, S > >
 
struct  iterator_traits< common_iterator< I, S > >
 
class  basic_const_iterator
 
class  counted_iterator
 
struct  iterator_traits< counted_iterator< I >, enable_if_t< Internal::counted_iterator_trait_requirements< I > > >
 
struct  iterator_traits
 
struct  indirectly_readable_traits
 
struct  indirectly_readable_traits< T * >
 
struct  indirectly_readable_traits< const T >
 
struct  incrementable_traits
 
struct  incrementable_traits< T * >
 
struct  incrementable_traits< const T >
 
class  move_iterator
 
class  move_sentinel
 
struct  unreachable_sentinel_t
 
struct  contiguous_iterator_tag
 Identifying tag for contagious iterators. More...
 
struct  default_sentinel_t
 Add the default_sentinel struct from C++20. More...
 
struct  iterator_traits< T * >
 
struct  iterator_traits< back_insert_iterator< Container > >
 
struct  iterator_traits< front_insert_iterator< Container > >
 
struct  iterator_traits< insert_iterator< Container > >
 
struct  hash< optional< T > >
 
class  static_pool_concurrent_allocator
 
class  binary_semaphore
 
class  combinable
 
class  condition_variable
 
class  condition_variable_any
 
struct  thread_id
 
class  concurrent_fixed_unordered_map
 
class  concurrent_fixed_unordered_multimap
 
class  concurrent_fixed_unordered_set
 
class  concurrent_fixed_unordered_multiset
 
class  concurrent_unordered_map
 
class  concurrent_unordered_multimap
 
class  concurrent_unordered_set
 
class  concurrent_unordered_multiset
 
class  concurrent_vector
 
struct  lock_free_intrusive_stack_node
 
struct  lock_free_intrusive_stack_base_hook
 
struct  lock_free_intrusive_stack_member_hook
 
class  lock_free_intrusive_stack
 
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  exponential_backoff
 
class  upgrade_lock
 
struct  defer_lock_t
 
struct  try_to_lock_t
 
struct  adopt_lock_t
 
class  lock_guard
 
class  unique_lock
 
class  shared_lock
 
class  mutex
 
class  recursive_mutex
 
class  scoped_lock
 
class  scoped_lock<>
 
class  scoped_lock< Mutex >
 
class  semaphore
 
class  shared_mutex
 
class  spin_mutex
 
struct  thread_desc
 
class  thread
 
struct  hash< thread_id >
 
class  ThreadEvents
 
struct  from_range_t
 
class  is_reference_wrapper
 
struct  unwrap_reference
 
struct  unwrap_reference< AZStd::reference_wrapper< T > >
 
struct  unwrap_ref_decay
 
struct  checked_deleter
 
struct  checked_array_deleter
 
class  enable_shared_from_this
 
class  enable_shared_from_this2
 
struct  IntrusivePtrCountPolicy
 
struct  hash< intrusive_ptr< T > >
 
struct  intrusive_default_delete
 
class  intrusive_refcount
 
class  scoped_array
 
class  scoped_ptr
 
class  shared_array
 
class  weak_ptr
 
struct  hash< unique_ptr< T, Deleter > >
 
struct  alphanum_less
 Functor class to compare two objects with the "Alphanum Algorithm". More...
 
struct  hash< basic_fixed_string< Element, MaxElementCount, Traits > >
 
class  regex_traits
 
struct  CmpCS
 
struct  CmpIcase
 
struct  CmpCollate
 
struct  RegexTraitsBase
 
struct  ClassNames
 
class  RegexTraits
 
class  regex_traits< char >
 
class  regex_traits< wchar_t >
 
class  sub_match
 
class  match_results
 
struct  RegExBuffer
 
struct  RegExBitmap
 
struct  RegExSequence
 
class  NodeBase
 
class  RootNode
 
class  NodeEndGroup
 
class  NodeAssert
 
class  NodeCapture
 
class  NodeBack
 
class  NodeString
 
class  NodeClass
 
class  NodeEndif
 
class  NodeIf
 
class  NodeEndRepetition
 
struct  LoopValues
 
class  NodeRepetition
 
class  Builder
 
class  BackTracingState
 
class  TgtState
 
class  Matcher
 
class  Parser
 
class  basic_regex
 
class  regex_iterator
 
class  regex_token_iterator
 
struct  hash< basic_string< Element, Traits, Allocator > >
 
struct  hash< basic_string_view< Element, Traits > >
 
struct  hash< AZStd::tuple< Types...> >
 
struct  basic_common_reference
 
struct  common_reference
 
struct  function_traits
 
struct  is_bounded_array
 
struct  is_bounded_array< T[N]>
 
struct  is_unbounded_array
 
struct  is_unbounded_array< T[]>
 
struct  is_function_pointer
 
struct  remove_cvref
 
struct  default_destruct
 
struct  no_destruct
 
class  static_storage
 
struct  tuple_elements_sequence
 
struct  type_id_holder
 
struct  type_id_holder< T const >
 
struct  type_id_holder< T volatile >
 
struct  type_id_holder< T const volatile >
 
struct  type_identity
 
struct  make_void
 
class  unexpected
 
class  expected
 
struct  unexpect_t
 Tag Type for in-place construction of the error type. More...
 
struct  default_delete
 
struct  default_delete< T[]>
 
struct  no_delete
 
struct  piecewise_construct_t
 
struct  native_thread_data_type
 

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
 
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  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

void to_string (string &str, const AZ::Vector2 &value)
 Prints a Vector2 with precision to 8 decimal places.
 
void to_string (string &str, const AZ::Vector3 &value)
 Prints a Vector3 with precision to 8 decimal places.
 
void to_string (string &str, const AZ::Vector4 &value)
 Prints a Vector4 with precision to 8 decimal places.
 
void to_string (string &str, const AZ::Quaternion &value)
 Prints a Quaternion with precision to 8 decimal places.
 
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.
 
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.
 
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.
 
void to_string (string &str, const AZ::Aabb &value)
 Prints an AABB as a pair of Vector3s with precision to 8 decimal places.
 
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 (AZStd::monostate)
 
 AZ_TYPE_INFO_SPECIALIZE_WITH_NAME_DECL (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 (AZStd::char_traits, AZ_TYPE_INFO_INTERNAL_TYPENAME)
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_BOTHFIX_UUID_DECL (AZStd::basic_string_view, AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_TYPENAME)
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_BOTHFIX_UUID_DECL (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 (AZStd::basic_fixed_string, AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_AUTO, AZ_TYPE_INFO_INTERNAL_TYPENAME)
 
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)
 
bool operator== (const stateless_allocator &left, const stateless_allocator &right)
 
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<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 >
decltype(auto) constexpr erase (fixed_vector< T, Capacity > &container, const U &value)
 
template<class T , size_t Capacity, class Predicate >
decltype(auto) constexpr erase_if (fixed_vector< T, Capacity > &container, Predicate predicate)
 
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 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 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 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 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 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 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 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 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 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 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 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 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>
decltype(auto) constexpr 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 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)
 
AZStd::size_t hash_next_bucket_size (AZStd::size_t n)
 
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 >
void to_wstring (AZStd::basic_string< wstring::value_type, wstring::traits_type, Allocator > &dest, AZStd::string_view src)
 
template<size_t MaxElementCount>
void to_wstring (AZStd::basic_fixed_string< wstring::value_type, MaxElementCount, wstring::traits_type > &dest, AZStd::string_view src)
 
void 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 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 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)
 
AZStd::sys_time_t GetTimeTicksPerSecond ()
 
AZStd::sys_time_t GetTimeNowTicks ()
 
AZStd::sys_time_t GetTimeNowMicroSecond ()
 
AZStd::sys_time_t GetTimeNowSecond ()
 
AZ::u64 GetTimeUTCMilliSecond ()
 
AZ::u64 GetTimeUTCMicroSecond ()
 
AZStd::chrono::microseconds GetCpuThreadTimeNowMicrosecond ()
 
AZStd::AZStd
tuple_element_tget
AZStd::pairpairObj 		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 T , class U >
constexpr T & get (AZStd::pair< T, U > &pairObj)
 
template<class T , class U >
constexpr T & get (AZStd::pair< U, T > &pairObj)
 
template<class T , class U >
constexpr const T & get (const AZStd::pair< T, U > &pairObj)
 
template<class T , class U >
constexpr const T & get (const AZStd::pair< U, T > &pairObj)
 
template<class T , class U >
constexpr T && get (AZStd::pair< T, U > &&pairObj)
 
template<class T , class U >
constexpr T && get (AZStd::pair< U, T > &&pairObj)
 
template<class T , class U >
constexpr const T && get (const AZStd::pair< T, U > &&pairObj)
 
template<class T , class U >
constexpr const T && get (const AZStd::pair< U, T > &&pairObj)
 
template<class T1 , class T2 >
constexpr tuple< T1, T2 > tuple_assign (const AZStd::pair< T1, T2 > &azPair)
 AZStd::pair to std::tuple function for replicating the functionality of std::tuple assignment operator from std::pair.
 
template<class T1 , class T2 >
constexpr tuple< T1, T2 > tuple_assign (AZStd::pair< T1, T2 > &&azPair)
 AZStd::pair to std::tuple function for replicating the functionality of std::tuple assignment operator from std::pair.
 
template<size_t I, class T , size_t N>
constexpr T & get (AZStd::array< T, N > &arr)
 
template<size_t I, class T , size_t N>
constexpr const T & get (const AZStd::array< T, N > &arr)
 
template<size_t I, class T , size_t N>
constexpr T && get (AZStd::array< T, N > &&arr)
 
template<size_t I, class T , size_t N>
constexpr const T && get (const AZStd::array< T, N > &&arr)
 
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<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 T1 , class T2 >
 pair (T1, T2) -> pair< T1, T2 >
 
template<class T1 , class T2 >
constexpr void swap (AZStd::pair< T1, T2 > &left, AZStd::pair< T1, T2 > &_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<L2>() == declval<R2>())>>
constexpr bool operator!= (const pair< L1, L2 > &left, const pair< R1, R2 > &right)
 

Variables

static constexpr const char * s_variantTypeId { "{1E8BB1E5-410A-4367-8FAA-D43A4DE14D4B}" }
 
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
 
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
 
template<class InputIt , class Alloc = allocator>
 forward_list< iter_value_t< InputIt >, Alloc >
 
struct AZStd::intrusive_list_node AZ_MAY_ALIAS
 
template<class T >
constexpr bool input_or_output_iterator< list_iterator< T > > = true
 
template<class InputIterator , class 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< range_key_type< R >, range_mapped_type< R >, less< range_key_type< R > >, Allocator >
 
template<class InputIterator , class 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< range_key_type< R >, range_mapped_type< R >, less< range_key_type< R > >, Allocator >
 
template<class Key , class T , class Allocator >
 multimap< Key, T, less< Key >, Allocator >
 
template<class InputIterator , class Allocator >
 set< iter_value_type< InputIterator >, less< iter_value_type< InputIterator > >, Allocator >
 
template<class InputIterator , class Allocator >
 multiset< iter_value_type< InputIterator >, less< iter_value_type< InputIterator > >, Allocator >
 
constexpr size_t dynamic_extent = numeric_limits<size_t>::max()
 
template<class InputIterator , class 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 R , class Allocator = allocator, class = enable_if_t<ranges::input_range<R>>>
 unordered_map< range_key_type< R >, range_mapped_type< R >, hash< range_key_type< R > >, equal_to< range_key_type< R > >, Allocator >
 
template<class Key , class T , class Allocator >
 unordered_map< Key, T, hash< Key >, equal_to< Key >, Allocator >
 
template<class InputIterator , class 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 R , class Allocator = allocator, class = enable_if_t<ranges::input_range<R>>>
 unordered_multimap< range_key_type< R >, range_mapped_type< R >, hash< range_key_type< R > >, equal_to< range_key_type< R > >, Allocator >
 
template<class Key , class T , class Allocator >
 unordered_multimap< Key, T, hash< Key >, equal_to< Key >, Allocator >
 
template<class T >
constexpr size_t variant_size_v = variant_size<T>::value
 
constexpr size_t variant_npos = static_cast<size_t>(-1)
 
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...>
 
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 default_sentinel_t default_sentinel {}
 
constexpr defer_lock_t defer_lock {}
 
constexpr try_to_lock_t try_to_lock {}
 
constexpr adopt_lock_t adopt_lock {}
 
template<class I1 , class I2 = I1>
constexpr bool indirectly_swappable = Internal::indirectly_swappable_impl<I1, I2>
 
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>
 
const int AZSTD_MAX_INSERTION_SORT_SIZE = 32
 
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 []
 
AZStd::AZStd I
 
AZStd::AZStd T1
 
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 {}
 
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)
 

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

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

enum 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

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

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

True if operation returns true for all elements in the range. True if range is empty.

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.
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
operandThe any to cast
resultThe variable to assign the result into if cast succeeds
Returns
true if conversion is successful, false if unsuccessful
template<class InputIter , class UnaryOperation >
constexpr bool AZStd::any_of ( InputIter  first,
InputIter  last,
UnaryOperation  operation 
)

True if operation returns true for any element in the range. False if the range is empty.

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)

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

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

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

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

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))

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

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

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)

Wraps the std::get function in the AZStd namespace This methods retrieves the tuple element at a particular index within the pair

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)

Wraps the std::get function in the AZStd namespace This methods retrieves the tuple element at a particular index within the pair

template<class T , class U >
constexpr T& AZStd::get ( AZStd::pair< T, U > &  pairObj)

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

template<class T , class U >
constexpr T& AZStd::get ( AZStd::pair< U, T > &  pairObj)

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

template<class T , class U >
constexpr const T& AZStd::get ( const AZStd::pair< T, U > &  pairObj)

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

template<class T , class U >
constexpr const T& AZStd::get ( const AZStd::pair< U, T > &  pairObj)

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

template<class T , class U >
constexpr T&& AZStd::get ( AZStd::pair< T, U > &&  pairObj)

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

template<class T , class U >
constexpr T&& AZStd::get ( AZStd::pair< U, T > &&  pairObj)

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

template<class T , class U >
constexpr const T&& AZStd::get ( const AZStd::pair< T, U > &&  pairObj)

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

template<class T , class U >
constexpr const T&& AZStd::get ( const AZStd::pair< U, T > &&  pairObj)

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

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

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

insertion_sort using default less predicate. [first, last), using operator<

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

insertion_sort using user compare. [first, last)

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

True if operation returns true for no elements in the range. True if range is empty.

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

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

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

Specialized algorithms 20.4.4. We extend that by adding faster specialized versions when we have trivial assign type.

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

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

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

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
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
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
template<class T , class... Args>
constexpr bool AZStd::constructible_from
Initial value:
= conjunction_v<bool_constant<destructible<T>>,
is_constructible<T, Args...> >
template<class Derived , class Base >
constexpr bool AZStd::derived_from
Initial value:
= conjunction_v<is_base_of<Base, Derived>,
is_convertible<const volatile Derived*, const volatile Base*>>
AZStd::AZStd AZStd::I

Wraps the std::get function in the AZStd namespace This methods retrieves the tuple element at a particular index within the pair

template<class In , class Out >
constexpr bool AZStd::indirectly_movable
Initial value:
= conjunction_v<bool_constant<indirectly_readable<In>>,
bool_constant<indirectly_writable<Out, iter_rvalue_reference_t<In>>>>
template<class T >
constexpr bool AZStd::input_or_output_iterator
Initial value:
= conjunction_v<bool_constant<!is_void_v<T>>,
bool_constant<weakly_incrementable<T>>>
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
}
template<class T >
constexpr bool AZStd::move_constructible
Initial value:
= conjunction_v<bool_constant<constructible_from<T, T>>,
bool_constant<convertible_to<T, T>>>
template<class R , class T , class U >
constexpr bool AZStd::relation
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>>>
template<class S , class I >
constexpr bool AZStd::sentinel_for
Initial value:
= conjunction_v<
bool_constant<semiregular<S>>,
bool_constant<input_or_output_iterator<I>>,
bool_constant<Internal::weakly_equality_comparable_with<S, I>>>