Embedded Template Library  1.0
etl Namespace Reference

Namespaces

 private_type_traits
 is_class
 

Classes

class  type_with_alignment
 
struct  aligned_storage
 
struct  aligned_storage_as
 
class  array_exception
 
class  array_out_of_range
 
class  array
 
class  array_view_exception
 The base class for array_view exceptions. More...
 
class  array_view_bounds
 
class  array_view_uninitialised
 
class  array_view
 Array view. More...
 
class  array_wrapper_exception
 The base class for array_wrapper exceptions. More...
 
class  array_wrapper_bounds
 
class  array_wrapper
 Array wrapper. More...
 
class  atomic
 For all types except bool and pointers. More...
 
class  atomic< T * >
 Specialisation for pointers. More...
 
class  basic_format_spec
 basic_format_spec More...
 
class  string_exception
 
class  string_empty
 
class  string_out_of_bounds
 
class  string_iterator
 
class  string_truncation
 
class  string_base
 
class  ibasic_string
 
class  basic_string_stream
 
class  binary_exception
 
class  binary_out_of_range
 
struct  max_value_for_nbits
 Definition for non-zero NBITS. More...
 
struct  max_value_for_nbits< 0 >
 Specialisation for when NBITS == 0. More...
 
struct  bit
 
class  bit_stream
 
class  bitset_exception
 
class  bitset_nullptr
 
class  bitset_type_too_small
 
class  ibitset
 
class  bitset
 
class  bloom_filter
 
class  bresenham_line
 
class  buffer_descriptors
 buffer_descriptors More...
 
class  callback
 
class  callback_service
 
struct  callback_timer_data
 The configuration of a timer. More...
 
class  icallback_timer
 Interface for callback timer. More...
 
class  callback_timer
 The callback timer. More...
 
struct  char_traits_types
 
struct  char_traits_types< char >
 
struct  char_traits_types< wchar_t >
 
struct  char_traits_types< char16_t >
 
struct  char_traits_types< char32_t >
 
struct  char_traits
 Character traits for any character type. More...
 
struct  checksum_policy_sum
 Standard addition checksum policy. More...
 
struct  checksum_policy_bsd
 BSD checksum policy. More...
 
struct  checksum_policy_xor
 Standard XOR checksum policy. More...
 
struct  checksum_policy_xor_rotate
 XOR-rotate checksum policy. More...
 
struct  checksum_policy_parity
 Parity checksum policy. More...
 
class  checksum
 Standard Checksum. More...
 
class  bsd_checksum
 BSD Checksum. More...
 
class  xor_checksum
 XOR Checksum. More...
 
class  xor_rotate_checksum
 XOR-shift Checksum. More...
 
class  parity_checksum
 Parity Checksum. More...
 
class  circular_buffer_exception
 Exception for the circular_buffer. More...
 
class  circular_buffer_empty
 Empty exception for the circular_buffer. More...
 
class  circular_buffer_base
 
class  icircular_buffer
 
class  circular_buffer
 
class  circular_buffer_ext
 
struct  combinations
 
struct  compare
 
class  constant
 
class  cumulative_moving_average
 
class  cumulative_moving_average< T, SAMPLE_SIZE_, SCALING_, true, false >
 
class  cumulative_moving_average< T, 0, SCALING_, true, false >
 
class  cumulative_moving_average< T, SAMPLE_SIZE_, 1U, false, true >
 
class  cumulative_moving_average< T, 0U, 1U, false, true >
 
class  cyclic_value
 
class  cyclic_value< T, FIRST, LAST, typename etl::enable_if<(FIRST==0) &&(LAST==0)>::type >
 
class  debounce
 
class  debounce< VALID_COUNT, HOLD_COUNT, 0 >
 
class  debounce< VALID_COUNT, 0, 0 >
 
class  debounce< 0, 0, 0 >
 
class  delegate_exception
 The base class for delegate exceptions. More...
 
class  delegate_uninitialised
 The exception thrown when the delegate is uninitialised. More...
 
class  delegate
 
class  delegate< TReturn(TParams...)>
 
class  delegate_service
 
class  factory_exception
 
class  factory_cannot_create
 
class  factory_did_not_create
 
class  factory
 
class  deque_exception
 
class  deque_full
 
class  deque_empty
 
class  deque_out_of_bounds
 
class  deque_incompatible_type
 
class  deque_base
 
class  ideque
 
class  deque
 
struct  endian
 
struct  endianness
 
class  exception
 
class  icache
 
struct  factorial
 
struct  factorial< 0 >
 
struct  fibonacci
 
struct  fibonacci< 1 >
 
struct  fibonacci< 0 >
 
class  fixed_iterator
 
class  flags
 
class  iflat_map
 
class  flat_map
 
class  iflat_multimap
 
class  flat_multimap
 
class  iflat_multiset
 
class  flat_multiset
 
class  iflat_set
 
class  flat_set
 
struct  fnv_1_policy_64
 
class  fnv_1_64
 
struct  fnv_1a_policy_64
 
class  fnv_1a_64
 
struct  fnv_1_policy_32
 
class  fnv_1_32
 
struct  fnv_1a_policy_32
 
class  fnv_1a_32
 
class  forward_list_exception
 
class  forward_list_full
 
class  forward_list_empty
 
class  forward_list_iterator
 
class  forward_list_no_pool
 
class  forward_list_base
 
class  iforward_list
 
class  forward_list
 
class  forward_list_ext
 Template deduction guides. More...
 
class  frame_check_sequence
 
class  fsm_exception
 Base exception class for FSM. More...
 
class  fsm_null_state_exception
 Exception for null state pointer. More...
 
class  fsm_state_id_exception
 Exception for invalid state id. More...
 
class  fsm_state_list_exception
 Exception for incompatible state list. More...
 
class  fsm_state_list_order_exception
 Exception for incompatible order state list. More...
 
class  ifsm_state
 Interface class for FSM states. More...
 
class  fsm
 The FSM class. More...
 
class  fsm_state
 
class  fsm_state< TContext, TDerived, STATE_ID_, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, void >
 
class  fsm_state< TContext, TDerived, STATE_ID_, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, void, void >
 
class  fsm_state< TContext, TDerived, STATE_ID_, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, void, void, void >
 
class  fsm_state< TContext, TDerived, STATE_ID_, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, void, void, void, void >
 
class  fsm_state< TContext, TDerived, STATE_ID_, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, void, void, void, void, void >
 
class  fsm_state< TContext, TDerived, STATE_ID_, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, void, void, void, void, void, void >
 
class  fsm_state< TContext, TDerived, STATE_ID_, T1, T2, T3, T4, T5, T6, T7, T8, T9, void, void, void, void, void, void, void >
 
class  fsm_state< TContext, TDerived, STATE_ID_, T1, T2, T3, T4, T5, T6, T7, T8, void, void, void, void, void, void, void, void >
 
class  fsm_state< TContext, TDerived, STATE_ID_, T1, T2, T3, T4, T5, T6, T7, void, void, void, void, void, void, void, void, void >
 
class  fsm_state< TContext, TDerived, STATE_ID_, T1, T2, T3, T4, T5, T6, void, void, void, void, void, void, void, void, void, void >
 
class  fsm_state< TContext, TDerived, STATE_ID_, T1, T2, T3, T4, T5, void, void, void, void, void, void, void, void, void, void, void >
 
class  fsm_state< TContext, TDerived, STATE_ID_, T1, T2, T3, T4, void, void, void, void, void, void, void, void, void, void, void, void >
 
class  fsm_state< TContext, TDerived, STATE_ID_, T1, T2, T3, void, void, void, void, void, void, void, void, void, void, void, void, void >
 
class  fsm_state< TContext, TDerived, STATE_ID_, T1, T2, void, void, void, void, void, void, void, void, void, void, void, void, void, void >
 
class  fsm_state< TContext, TDerived, STATE_ID_, T1, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void >
 
class  fsm_state< TContext, TDerived, STATE_ID_, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void >
 
class  ifunction
 
class  ifunction< void >
 
class  function
 
class  function< TObject, void >
 
class  function< void, TParameter >
 
class  function< void, void >
 
class  function_mp
 
class  function_mv
 
class  function_imp
 
class  function_imv
 
class  function_fp
 
class  function_fv
 
class  reference_wrapper
 
struct  less
 
struct  greater
 
struct  equal_to
 
struct  not_equal_to
 
struct  unary_function
 
struct  binary_function
 
class  binder1st
 
class  binder2nd
 
struct  larger_int_type
 Defines a type that is as larger or larger than the specified type. Will return the specified type is there is not a larger type. More...
 
struct  larger_uint_type
 Defines a type that is as larger or larger than the specified type. Will return the specified type is there is not a larger type. More...
 
struct  larger_type
 Defines a type that is as larger or larger than the specified type. Will return the specified type is there is not a larger type. The returned type will be of the same sign. More...
 
struct  larger_type< T, false >
 
struct  larger_type< T, true >
 
class  message_router_exception
 Base exception class for message router. More...
 
class  message_router_illegal_id
 Router id is out of the legal range. More...
 
class  imessage_router
 This is the base of all message routers. More...
 
class  null_message_router
 This router can be used as a sink for messages or a 'null source' router. More...
 
class  message_producer
 This router can be used as a producer-only of messages, such an interrupt routine. More...
 
struct  smallest_uint_for_bits
 Template to determine the smallest unsigned int type that can contain a value with the specified number of bits. Defines 'type' which is the type of the smallest unsigned integer. More...
 
struct  smallest_int_for_bits
 Template to determine the smallest signed int type that can contain a value with the specified number of bits. Defines 'type' which is the type of the smallest signed integer. More...
 
struct  smallest_uint_for_value
 Template to determine the smallest unsigned int type that can contain the specified unsigned value. Defines 'type' which is the type of the smallest unsigned integer. More...
 
struct  smallest_int_for_value
 Template to determine the smallest int type that can contain the specified signed value. Defines 'type' which is the type of the smallest signed integer. More...
 
struct  type_id_pair
 The type/id pair type to use for type/id lookup template parameters. More...
 
struct  type_type_pair
 The type/type pair type to use for type/type lookup template parameters. More...
 
struct  integral_constant
 integral_constant More...
 
struct  bool_constant
 
struct  remove_reference
 negation More...
 
struct  remove_pointer
 remove_pointer More...
 
struct  add_pointer
 add_pointer More...
 
struct  is_const
 is_const More...
 
struct  remove_const
 remove_const More...
 
struct  add_const
 add_const More...
 
struct  is_volatile
 is_volatile More...
 
struct  remove_volatile
 remove_volatile More...
 
struct  add_volatile
 add_volatile More...
 
struct  remove_cv
 remove_cv More...
 
struct  add_cv
 add_cv More...
 
struct  is_integral
 is_integral More...
 
struct  is_signed
 is_signed More...
 
struct  is_unsigned
 is_unsigned More...
 
struct  is_floating_point
 is_floating_point More...
 
struct  is_same
 is_same More...
 
struct  is_void
 is_void More...
 
struct  is_arithmetic
 is_arithmetic More...
 
struct  is_fundamental
 is_fundamental More...
 
struct  is_compound
 is_compound More...
 
struct  is_array
 is_array More...
 
struct  is_pointer
 is_pointer More...
 
struct  is_reference
 is_reference More...
 
struct  is_lvalue_reference
 is_lvalue_reference More...
 
struct  is_pod
 is_rvalue_reference More...
 
struct  is_trivially_constructible
 is_trivially_constructible More...
 
struct  is_trivially_copy_constructible
 is_trivially_copy_constructible More...
 
struct  is_trivially_destructible
 is_trivially_destructible More...
 
struct  is_trivially_copy_assignable
 is_trivially_copy_assignable More...
 
struct  is_trivially_copyable
 is_trivially_copyable More...
 
struct  conditional
 conditional More...
 
struct  conditional< false, T, F >
 
struct  make_signed
 make_signed More...
 
struct  make_unsigned
 make_unsigned More...
 
struct  enable_if
 enable_if More...
 
struct  extent
 extent More...
 
struct  remove_extent
 remove_extent More...
 
struct  remove_all_extents
 remove_all_extents More...
 
struct  rank
 rank More...
 
struct  decay
 decay More...
 
struct  is_base_of
 is_base_of More...
 
struct  is_class
 is_class More...
 
struct  add_lvalue_reference
 add_lvalue_reference More...
 
struct  alignment_of
 add_rvalue_reference More...
 
struct  alignment_of< void >
 
struct  conditional_integral_constant
 conditional_integral_constant More...
 
struct  conditional_integral_constant< true, T, TRUE_VALUE, FALSE_VALUE >
 
struct  conditional_integral_constant< false, T, TRUE_VALUE, FALSE_VALUE >
 
struct  types
 A set of templates to allow related types to be derived. More...
 
struct  types< T * >
 
struct  types< T *const >
 
struct  types< T & >
 
struct  size_of
 size_of More...
 
struct  size_of< void >
 
class  variant_pool_exception
 
class  variant_pool_cannot_create
 
class  variant_pool_did_not_create
 
class  variant_pool
 
struct  hash
 
struct  hash< bool >
 
struct  hash< char >
 
struct  hash< signed char >
 
struct  hash< unsigned char >
 
struct  hash< wchar_t >
 
struct  hash< short >
 
struct  hash< unsigned short >
 
struct  hash< int >
 
struct  hash< unsigned int >
 
struct  hash< long >
 
struct  hash< long long >
 
struct  hash< unsigned long >
 
struct  hash< unsigned long long >
 
struct  hash< float >
 
struct  hash< double >
 
struct  hash< long double >
 
struct  hash< T * >
 
class  hash_exception
 
class  hash_finalised
 
class  indirect_vector_buffer_missmatch
 
class  iindirect_vector
 
class  indirect_vector
 
class  indirect_vector_ext
 Template deduction guides. More...
 
class  instance_count
 
struct  integral_limits
 
struct  integral_limits< void >
 
struct  integral_limits< signed char >
 
struct  integral_limits< unsigned char >
 
struct  integral_limits< char >
 
struct  integral_limits< short >
 
struct  integral_limits< unsigned short >
 
struct  integral_limits< int >
 
struct  integral_limits< unsigned int >
 
struct  integral_limits< long >
 
struct  integral_limits< unsigned long >
 
struct  integral_limits< long long >
 
struct  integral_limits< unsigned long long >
 
class  intrusive_forward_list_exception
 
class  intrusive_forward_list_empty
 
class  intrusive_forward_list_iterator_exception
 
class  intrusive_forward_list_index_exception
 
class  intrusive_forward_list_unsorted
 
class  intrusive_forward_list_base
 
class  intrusive_forward_list
 
class  link_exception
 Link exception. More...
 
class  not_unlinked_exception
 not unlinked exception. More...
 
struct  forward_link
 A forward link. More...
 
struct  bidirectional_link
 A bidirectional link. More...
 
struct  tree_link
 A binary tree link. More...
 
class  intrusive_list_exception
 
class  intrusive_list_empty
 
class  intrusive_list_iterator_exception
 
class  intrusive_list_unsorted
 
class  intrusive_list_base
 
class  intrusive_list
 
class  intrusive_queue_exception
 
class  intrusive_queue_empty
 
class  intrusive_queue_base
 
class  intrusive_queue
 
class  intrusive_stack_exception
 
class  intrusive_stack_empty
 
class  intrusive_stack_base
 
class  intrusive_stack
 
class  io_port_rw
 Read write port. More...
 
class  io_port_ro
 Read only port. More...
 
class  io_port_wo
 Write only port. More...
 
class  io_port_wos
 Write only port with shadow register. More...
 
class  io_port_rw< T, 0 >
 
class  io_port_ro< T, 0 >
 
class  io_port_wo< T, 0 >
 
class  io_port_wos< T, 0 >
 
struct  input_iterator_tag
 
struct  output_iterator_tag
 
struct  forward_iterator_tag
 
struct  bidirectional_iterator_tag
 
struct  random_access_iterator_tag
 
struct  iterator_traits
 
struct  iterator_traits< T * >
 
struct  iterator_traits< const T * >
 
class  reverse_iterator
 
struct  iterator
 iterator More...
 
struct  is_input_iterator
 
struct  is_output_iterator
 
struct  is_forward_iterator
 
struct  is_bidirectional_iterator
 
struct  is_random_iterator
 
struct  is_input_iterator_concept
 
struct  is_output_iterator_concept
 
struct  is_forward_iterator_concept
 
struct  is_bidirectional_iterator_concept
 
struct  is_random_iterator_concept
 
struct  jenkins_policy
 
class  jenkins
 jenkins More...
 
struct  largest_type
 
struct  largest_type< T1, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void >
 
struct  largest_alignment
 
struct  largest_alignment< T1, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void >
 
struct  largest
 
class  numeric_limits
 
class  list_exception
 
class  list_full
 
class  list_empty
 
class  list_iterator
 
class  list_unsorted
 
class  list_no_pool
 
class  list_base
 
class  ilist
 
class  list
 A templated list implementation that uses a fixed size buffer. More...
 
class  list_ext
 Template deduction guides. More...
 
struct  log
 
struct  log< 1, BASE >
 
struct  log< 0, BASE >
 
struct  log2
 
struct  log10
 
class  map_exception
 
class  map_full
 
class  map_out_of_bounds
 
class  map_iterator
 
class  map_base
 
class  imap
 
class  map
 A templated map implementation that uses a fixed size buffer. More...
 
struct  default_delete
 
struct  default_delete< T[]>
 
class  unique_ptr
 
class  unique_ptr< T[], TDeleter >
 
struct  create_copy
 
struct  wipe_on_destruct
 
class  uninitialized_buffer
 
class  uninitialized_buffer_of
 
struct  size_type_lookup
 
struct  size_type_lookup< etl::memory_model::MEMORY_MODEL_SMALL >
 
struct  size_type_lookup< etl::memory_model::MEMORY_MODEL_MEDIUM >
 
struct  size_type_lookup< etl::memory_model::MEMORY_MODEL_LARGE >
 
struct  size_type_lookup< etl::memory_model::MEMORY_MODEL_HUGE >
 
class  message_exception
 
class  unhandled_message_exception
 
class  imessage
 
class  message
 
class  message_bus_exception
 Base exception class for message bus. More...
 
class  message_bus_too_many_subscribers
 Too many subscribers. More...
 
class  imessage_bus
 Interface for message bus. More...
 
class  message_bus
 The message bus. More...
 
class  message_packet
 
class  message_packet< T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, void >
 
class  message_packet< T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, void, void >
 
class  message_packet< T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, void, void, void >
 
class  message_packet< T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, void, void, void, void >
 
class  message_packet< T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, void, void, void, void, void >
 
class  message_packet< T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, void, void, void, void, void, void >
 
class  message_packet< T1, T2, T3, T4, T5, T6, T7, T8, T9, void, void, void, void, void, void, void >
 
class  message_packet< T1, T2, T3, T4, T5, T6, T7, T8, void, void, void, void, void, void, void, void >
 
class  message_packet< T1, T2, T3, T4, T5, T6, T7, void, void, void, void, void, void, void, void, void >
 
class  message_packet< T1, T2, T3, T4, T5, T6, void, void, void, void, void, void, void, void, void, void >
 
class  message_packet< T1, T2, T3, T4, T5, void, void, void, void, void, void, void, void, void, void, void >
 
class  message_packet< T1, T2, T3, T4, void, void, void, void, void, void, void, void, void, void, void, void >
 
class  message_packet< T1, T2, T3, void, void, void, void, void, void, void, void, void, void, void, void, void >
 
class  message_packet< T1, T2, void, void, void, void, void, void, void, void, void, void, void, void, void, void >
 
class  message_packet< T1, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void >
 
class  message_router
 
class  message_router< TDerived, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, void >
 
class  message_router< TDerived, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, void, void >
 
class  message_router< TDerived, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, void, void, void >
 
class  message_router< TDerived, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, void, void, void, void >
 
class  message_router< TDerived, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, void, void, void, void, void >
 
class  message_router< TDerived, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, void, void, void, void, void, void >
 
class  message_router< TDerived, T1, T2, T3, T4, T5, T6, T7, T8, T9, void, void, void, void, void, void, void >
 
class  message_router< TDerived, T1, T2, T3, T4, T5, T6, T7, T8, void, void, void, void, void, void, void, void >
 
class  message_router< TDerived, T1, T2, T3, T4, T5, T6, T7, void, void, void, void, void, void, void, void, void >
 
class  message_router< TDerived, T1, T2, T3, T4, T5, T6, void, void, void, void, void, void, void, void, void, void >
 
class  message_router< TDerived, T1, T2, T3, T4, T5, void, void, void, void, void, void, void, void, void, void, void >
 
class  message_router< TDerived, T1, T2, T3, T4, void, void, void, void, void, void, void, void, void, void, void, void >
 
class  message_router< TDerived, T1, T2, T3, void, void, void, void, void, void, void, void, void, void, void, void, void >
 
class  message_router< TDerived, T1, T2, void, void, void, void, void, void, void, void, void, void, void, void, void, void >
 
class  message_router< TDerived, T1, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void >
 
struct  message_timer_data
 The configuration of a timer. More...
 
class  imessage_timer
 Interface for message timer. More...
 
class  message_timer
 The message timer. More...
 
class  multimap_exception
 
class  multimap_full
 
class  multimap_out_of_bounds
 
class  multimap_iterator
 
class  multimap_base
 
class  imultimap
 
class  multimap
 A templated multimap implementation that uses a fixed size buffer. More...
 
class  multiset_exception
 
class  multiset_full
 
class  multiset_out_of_bounds
 
class  multiset_iterator
 
class  multiset_base
 
class  imultiset
 
class  multiset
 A templated multiset implementation that uses a fixed size buffer. More...
 
class  murmur3
 
class  mutex
 This mutex class is implemented using FreeRTOS's mutexes. More...
 
class  null_type
 
class  observer_exception
 
class  observer_list_full
 
class  observable
 
class  observer
 
class  observer< T1, T2, T3, T4, T5, T6, T7 >
 
class  observer< T1, T2, T3, T4, T5, T6 >
 
class  observer< T1, T2, T3, T4, T5 >
 
class  observer< T1, T2, T3, T4 >
 
class  observer< T1, T2, T3 >
 
class  observer< T1, T2 >
 
class  observer< T1 >
 
class  nullopt_t
 
class  optional_exception
 
class  optional_invalid
 
class  optional
 
class  packet
 
struct  parameter_type
 Determine how to pass parameters. More...
 
class  pearson
 
struct  permutations
 
struct  permutations< NV, 0 >
 
class  pool_exception
 
class  pool_no_allocation
 
class  pool_object_not_in_pool
 
class  pool_element_size
 
class  ipool
 
class  generic_pool
 
class  pool
 
struct  power
 
struct  power< NV, 0 >
 
struct  power_of_2_round_up
 
struct  power_of_2_round_up< 0 >
 
struct  power_of_2_round_down
 
struct  power_of_2_round_down< 0 >
 
struct  power_of_2_round_down< 1 >
 
struct  power_of_2_round_down< 2 >
 
struct  is_power_of_2
 
struct  is_power_of_2< 0 >
 
struct  is_power_of_2< 1 >
 
class  priority_queue_exception
 
class  priority_queue_full
 
class  priority_queue_iterator
 
class  ipriority_queue
 This is the base for all priority queues that contain a particular type. More...
 
class  priority_queue
 
class  crc16_table_poly_0x1021
 Table and add value. More...
 
class  crc16_table_poly_0x1021_reflected
 Table and add value. More...
 
struct  crc16_policy_poly_0x1021
 
struct  crc16_policy_poly_0x1021< INITIAL, XOR_OUT, true >
 CRC16 Poly 0x1021 reflected policy specialisation. More...
 
class  crc16_poly_0x1021
 CRC16 Poly 0x1021. More...
 
class  crc16_table_poly_0x8005
 Table and add value. More...
 
class  crc16_table_poly_0x8005_reflected
 Table and add value. More...
 
struct  crc16_policy_poly_0x8005
 
struct  crc16_policy_poly_0x8005< INITIAL, XOR_OUT, true >
 CRC16 Poly 0x8005 reflected policy. More...
 
class  crc16_poly_0x8005
 CRC16 Poly 0x8005. More...
 
class  crc32_table_poly_0x04c11db7
 Table and add value. More...
 
class  crc32_table_poly_0x04c11db7_reflected
 Table and add value. More...
 
struct  crc32_policy_poly_0x04c11db7
 
struct  crc32_policy_poly_0x04c11db7< INITIAL, XOR_OUT, true >
 CRC32 Poly 0x04C11DB7 reflected policy specialisation. More...
 
class  crc32_poly_0x04c11db7
 CRC32 Poly 0x04C11DB7. More...
 
class  crc32_table_poly_0x1edc6f41
 Table and add value. More...
 
class  crc32_table_poly_0x1edc6f41_reflected
 Table and add value. More...
 
struct  crc32_policy_poly_0x1edc6f41
 
struct  crc32_policy_poly_0x1edc6f41< INITIAL, XOR_OUT, true >
 CRC32 Poly 0x1EDC6F41 reflected policy specialisation. More...
 
class  crc32_poly_0x1edc6f41
 CRC32 Poly 0x1EDC6F41. More...
 
class  crc64_table_poly_0x42f0e1eba9ea3693
 Table and add value. More...
 
class  crc64_table_poly_0x42f0e1eba9ea3693_reflected
 Table and add value. More...
 
struct  crc64_policy_poly_0x42f0e1eba9ea3693
 
struct  crc64_policy_poly_0x42f0e1eba9ea3693< INITIAL, XOR_OUT, true >
 CRC64 Poly 0x42F0E1EBA9EA3693 reflected policy specialisation. More...
 
class  crc64_poly_0x42f0e1eba9ea3693
 CRC64 Poly 0x42F0E1EBA9EA3693. More...
 
class  crc8_table_poly_0x07
 
class  crc8_table_poly_0x07_reflected
 
struct  crc8_policy_poly_0x07
 
struct  crc8_policy_poly_0x07< INITIAL, XOR_OUT, true >
 CRC8 Poly 0x07 reflected policy specialisation. More...
 
class  crc8_poly_0x07
 CRC8 Poly 0x07. More...
 
class  ivector< T * >
 
class  ivector< const T * >
 
class  pvoidvector
 
class  vector_exception
 
class  vector_full
 
class  vector_empty
 
class  vector_out_of_bounds
 
class  vector_incompatible_type
 
class  vector_base
 
class  queue_exception
 
class  queue_full
 
class  queue_empty
 
class  queue_base
 
class  iqueue
 This is the base for all queues that contain a particular type. More...
 
class  queue
 
class  queue_spsc_isr_base
 
class  iqueue_spsc_isr
 This is the base for all queue_spsc_isrs that contain a particular type. More...
 
class  queue_spsc_isr
 
class  iqueue_spsc_locked_base
 
class  iqueue_spsc_locked
 This is the base for all queue_spsc_isrs that contain a particular type. More...
 
class  queue_spsc_locked
 
struct  radix
 
class  random
 
class  random_xorshift
 
class  random_lcg
 
class  random_clcg
 
class  random_lsfr
 
class  random_mwc
 
class  random_pcg
 
struct  ratio
 
class  flat_map_exception
 
class  flat_map_full
 
class  flat_map_out_of_bounds
 
class  ireference_flat_map
 
class  reference_flat_map
 
class  flat_multimap_exception
 
class  flat_multimap_full
 
class  ireference_flat_multimap
 
class  reference_flat_multimap
 
class  flat_multiset_exception
 
class  flat_multiset_full
 
class  flat_multiset_iterator
 
class  ireference_flat_multiset
 
class  reference_flat_multiset
 
class  flat_set_exception
 
class  flat_set_full
 
class  flat_set_iterator
 
class  ireference_flat_set
 
class  reference_flat_set
 
struct  scaled_rounding_t
 
class  scheduler_exception
 Base exception class for scheduler. More...
 
class  scheduler_no_tasks_exception
 'No tasks' exception. More...
 
class  scheduler_null_task_exception
 'Null tasks' exception. More...
 
class  scheduler_too_many_tasks_exception
 'Too many tasks' exception. More...
 
struct  scheduler_policy_sequential_single
 
struct  scheduler_policy_sequential_multiple
 
struct  scheduler_policy_highest_priority
 
struct  scheduler_policy_most_work
 
class  ischeduler
 Scheduler base. More...
 
class  scheduler
 Scheduler. More...
 
class  set_exception
 
class  set_full
 
class  set_out_of_bounds
 
class  set_iterator
 
class  set_base
 
class  iset
 
class  set
 A templated set implementation that uses a fixed size buffer. More...
 
struct  smallest_type
 
struct  smallest_type< T1, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void >
 
class  span
 Array view. More...
 
struct  sqrt
 Calculates the smallest value that, when squared, will be not greater than VALUE. More...
 
class  stack_exception
 
class  stack_full
 
class  stack_empty
 
class  stack_base
 
class  istack
 This is the base for all stacks that contain a particular type. More...
 
class  stack
 
class  istate_chart
 Simple Finite State Machine Interface. More...
 
class  state_chart
 Simple Finite State Machine. More...
 
class  string
 
class  string_ext
 
struct  string_pad_direction
 string_pad_direction More...
 
struct  whitespace
 whitespace More...
 
struct  whitespace< char >
 
struct  whitespace< wchar_t >
 
struct  whitespace< char16_t >
 
struct  whitespace< char32_t >
 
class  string_view_exception
 The base class for basic_string_view exceptions. More...
 
class  string_view_bounds
 
class  string_view_uninitialised
 
class  basic_string_view
 String view. More...
 
class  task_exception
 Base exception class for task. More...
 
class  task
 Task. More...
 
struct  timer
 Common definitions for the timer framework. More...
 
class  type_def
 
struct  type_id_lookup
 
struct  type_type_lookup
 
struct  type_select
 
struct  type_select< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 >
 
struct  type_select< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 >
 
struct  type_select< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 >
 
struct  type_select< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 >
 
struct  type_select< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 >
 
struct  type_select< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 >
 
struct  type_select< T0, T1, T2, T3, T4, T5, T6, T7, T8 >
 
struct  type_select< T0, T1, T2, T3, T4, T5, T6, T7 >
 
struct  type_select< T0, T1, T2, T3, T4, T5, T6 >
 
struct  type_select< T0, T1, T2, T3, T4, T5 >
 
struct  type_select< T0, T1, T2, T3, T4 >
 
struct  type_select< T0, T1, T2, T3 >
 
struct  type_select< T0, T1, T2 >
 
struct  type_select< T0, T1 >
 
struct  type_select< T0 >
 
struct  negation
 negation More...
 
struct  remove_reference< T & >
 
struct  remove_pointer< T * >
 
struct  remove_pointer< const T * >
 
struct  remove_pointer< volatile T * >
 
struct  remove_pointer< const volatile T * >
 
struct  remove_pointer< T *const >
 
struct  remove_pointer< const T *const >
 
struct  remove_pointer< volatile T *const >
 
struct  remove_pointer< const volatile T *const >
 
struct  is_const< const T >
 
struct  is_const< const volatile T >
 
struct  remove_const< const T >
 
struct  add_const< const T >
 
struct  is_volatile< volatile T >
 
struct  is_volatile< const volatile T >
 
struct  remove_volatile< volatile T >
 
struct  add_volatile< volatile T >
 
struct  is_integral< bool >
 
struct  is_integral< char >
 
struct  is_integral< unsigned char >
 
struct  is_integral< signed char >
 
struct  is_integral< wchar_t >
 
struct  is_integral< short >
 
struct  is_integral< unsigned short >
 
struct  is_integral< int >
 
struct  is_integral< unsigned int >
 
struct  is_integral< long >
 
struct  is_integral< unsigned long >
 
struct  is_integral< long long >
 
struct  is_integral< unsigned long long >
 
struct  is_integral< const T >
 
struct  is_integral< volatile T >
 
struct  is_integral< const volatile T >
 
struct  is_signed< char >
 
struct  is_signed< wchar_t >
 
struct  is_signed< signed char >
 
struct  is_signed< short >
 
struct  is_signed< int >
 
struct  is_signed< long >
 
struct  is_signed< long long >
 
struct  is_signed< float >
 
struct  is_signed< double >
 
struct  is_signed< long double >
 
struct  is_signed< const T >
 
struct  is_signed< volatile T >
 
struct  is_signed< const volatile T >
 
struct  is_unsigned< bool >
 
struct  is_unsigned< char >
 
struct  is_unsigned< unsigned char >
 
struct  is_unsigned< wchar_t >
 
struct  is_unsigned< unsigned short >
 
struct  is_unsigned< unsigned int >
 
struct  is_unsigned< unsigned long >
 
struct  is_unsigned< unsigned long long >
 
struct  is_unsigned< const T >
 
struct  is_unsigned< volatile T >
 
struct  is_unsigned< const volatile T >
 
struct  is_floating_point< float >
 
struct  is_floating_point< double >
 
struct  is_floating_point< long double >
 
struct  is_floating_point< const T >
 
struct  is_floating_point< volatile T >
 
struct  is_floating_point< const volatile T >
 
struct  is_same< T, T >
 
struct  is_void< void >
 
struct  is_array< T[]>
 
struct  is_array< T[MAXN]>
 
struct  is_pointer_helper
 is_pointer More...
 
struct  is_pointer_helper< T * >
 
struct  is_reference_helper
 is_reference More...
 
struct  is_reference_helper< T & >
 
struct  is_lvalue_reference_helper
 is_lvalue_reference More...
 
struct  is_lvalue_reference_helper< T & >
 
struct  make_signed< char >
 
struct  make_signed< unsigned char >
 
struct  make_signed< wchar_t >
 
struct  make_signed< unsigned short >
 
struct  make_signed< unsigned int >
 
struct  make_signed< unsigned long >
 
struct  make_signed< unsigned long long >
 
struct  make_signed< const T >
 
struct  make_signed< volatile T >
 
struct  make_signed< const volatile T >
 
struct  make_unsigned< char >
 
struct  make_unsigned< signed char >
 
struct  make_unsigned< short >
 
struct  make_unsigned< wchar_t >
 
struct  make_unsigned< int >
 
struct  make_unsigned< long >
 
struct  make_unsigned< long long >
 
struct  make_unsigned< const T >
 
struct  make_unsigned< volatile T >
 
struct  make_unsigned< const volatile T >
 
struct  enable_if< true, T >
 
struct  extent< T[], 0 >
 
struct  extent< T[], MAXN >
 
struct  extent< T[MAXN], 0 >
 
struct  extent< T[I], MAXN >
 
struct  remove_extent< T[]>
 
struct  remove_extent< T[MAXN]>
 
struct  remove_all_extents< T[]>
 
struct  remove_all_extents< T[MAXN]>
 
struct  rank< T[]>
 
struct  rank< T[MAXN]>
 
struct  is_base_of< TBase, TDerived, true >
 
struct  add_lvalue_reference< T & >
 
struct  add_lvalue_reference< void >
 
struct  add_lvalue_reference< const void >
 
struct  add_lvalue_reference< volatile void >
 
struct  add_lvalue_reference< const volatile void >
 
struct  is_one_of
 
class  u16string
 
class  u16string_ext
 
class  u32string
 
class  u32string_ext
 
class  unordered_map_exception
 
class  unordered_map_full
 
class  unordered_map_out_of_range
 
class  unordered_map_iterator
 
class  iunordered_map
 
class  unordered_map
 A templated unordered_map implementation that uses a fixed size buffer. More...
 
class  unordered_multimap_exception
 
class  unordered_multimap_full
 
class  unordered_multimap_out_of_range
 
class  unordered_multimap_iterator
 
class  iunordered_multimap
 
class  unordered_multimap
 A templated unordered_multimap implementation that uses a fixed size buffer. More...
 
class  unordered_multiset_exception
 
class  unordered_multiset_full
 
class  unordered_multiset_out_of_range
 
class  unordered_multiset_iterator
 
class  iunordered_multiset
 
class  unordered_multiset
 A templated unordered_multiset implementation that uses a fixed size buffer. More...
 
class  unordered_set_exception
 
class  unordered_set_full
 
class  unordered_set_out_of_range
 
class  unordered_set_iterator
 
class  iunordered_set
 
class  unordered_set
 A templated unordered_set implementation that uses a fixed size buffer. More...
 
struct  pair
 
struct  coordinate_2d
 2D coordinate type. More...
 
class  variant_exception
 
class  variant_incorrect_type_exception
 
class  variant
 
class  ivector
 
class  vector
 
class  vector_ext
 Template deduction guides. More...
 
class  vector< T *, MAX_SIZE_ >
 
class  vector_ext< T * >
 Template deduction guides. More...
 
class  visitable
 
class  visitable< T1, T2, T3 >
 
class  visitable< T1, T2 >
 
class  visitable< T1 >
 
class  visitor
 
class  visitor< T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 >
 
class  visitor< T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 >
 
class  visitor< T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 >
 
class  visitor< T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 >
 
class  visitor< T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 >
 
class  visitor< T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 >
 
class  visitor< T1, T2, T3, T4, T5, T6, T7, T8, T9 >
 
class  visitor< T1, T2, T3, T4, T5, T6, T7, T8 >
 
class  visitor< T1, T2, T3, T4, T5, T6, T7 >
 
class  visitor< T1, T2, T3, T4, T5, T6 >
 
class  visitor< T1, T2, T3, T4, T5 >
 
class  visitor< T1, T2, T3, T4 >
 
class  visitor< T1, T2, T3 >
 
class  visitor< T1, T2 >
 
class  visitor< T1 >
 
class  wstring
 
class  wstring_ext
 

Typedefs

typedef enum etl::memory_order memory_order
 
typedef etl::atomic< char > atomic_char
 
typedef etl::atomic< signed char > atomic_schar
 
typedef etl::atomic< unsigned char > atomic_uchar
 
typedef etl::atomic< short > atomic_short
 
typedef etl::atomic< unsigned short > atomic_ushort
 
typedef etl::atomic< int > atomic_int
 
typedef etl::atomic< unsigned int > atomic_uint
 
typedef etl::atomic< long > atomic_long
 
typedef etl::atomic< unsigned long > atomic_ulong
 
typedef etl::atomic< long long > atomic_llong
 
typedef etl::atomic< unsigned long long > atomic_ullong
 
typedef etl::atomic< wchar_t > atomic_wchar_t
 
typedef etl::atomic< char16_t > atomic_char16_t
 
typedef etl::atomic< char32_t > atomic_char32_t
 
typedef etl::atomic< uint16_t > atomic_uint16_t
 
typedef etl::atomic< int16_t > atomic_int16_t
 
typedef etl::atomic< uint32_t > atomic_uint32_t
 
typedef etl::atomic< int32_t > atomic_int32_t
 
typedef etl::atomic< uint64_t > atomic_uint64_t
 
typedef etl::atomic< int64_t > atomic_int64_t
 
typedef etl::atomic< int_least8_t > atomic_int_least8_t
 
typedef etl::atomic< uint_least8_t > atomic_uint_least8_t
 
typedef etl::atomic< int_least16_t > atomic_int_least16_t
 
typedef etl::atomic< uint_least16_t > atomic_uint_least16_t
 
typedef etl::atomic< int_least32_t > atomic_int_least32_t
 
typedef etl::atomic< uint_least32_t > atomic_uint_least32_t
 
typedef etl::atomic< int_least64_t > atomic_int_least64_t
 
typedef etl::atomic< uint_least64_t > atomic_uint_least64_t
 
typedef etl::atomic< int_fast8_t > atomic_int_fast8_t
 
typedef etl::atomic< uint_fast8_t > atomic_uint_fast8_t
 
typedef etl::atomic< int_fast16_t > atomic_int_fast16_t
 
typedef etl::atomic< uint_fast16_t > atomic_uint_fast16_t
 
typedef etl::atomic< int_fast32_t > atomic_int_fast32_t
 
typedef etl::atomic< uint_fast32_t > atomic_uint_fast32_t
 
typedef etl::atomic< int_fast64_t > atomic_int_fast64_t
 
typedef etl::atomic< uint_fast64_t > atomic_uint_fast64_t
 
typedef etl::atomic< intptr_t > atomic_intptr_t
 
typedef etl::atomic< uintptr_t > atomic_uintptr_t
 
typedef etl::atomic< size_t > atomic_size_t
 
typedef etl::atomic< ptrdiff_t > atomic_ptrdiff_t
 
typedef etl::atomic< intmax_t > atomic_intmax_t
 
typedef etl::atomic< uintmax_t > atomic_uintmax_t
 
typedef std::atomic< bool > atomic_bool
 
typedef crc16_poly_0x8005< 0x0000U, 0x0000U, true > crc16
 
typedef crc16_poly_0x1021< 0x1D0FU, 0x0000U, false > crc16_aug_ccitt
 
typedef crc16_poly_0x1021< 0xFFFFU, 0x0000U, false > crc16_ccitt
 
typedef crc16_poly_0x1021< 0xFFFFU, 0xFFFFU, false > crc16_genibus
 
typedef crc16_poly_0x1021< 0x0000U, 0x0000U, true > crc16_kermit
 
typedef crc16_poly_0x8005< 0xFFFFU, 0x0000U, true > crc16_modbus
 
typedef crc16_poly_0x8005< 0xFFFFU, 0xFFFFU, true > crc16_usb
 
typedef crc16_poly_0x1021< 0xFFFFU, 0xFFFFU, true > crc16_x25
 
typedef crc16_poly_0x1021< 0x0000U, 0x0000U, false > crc16_xmodem
 
typedef crc32_poly_0x04c11db7< 0xFFFFFFFFU, 0xFFFFFFFFU, true > crc32
 
typedef crc32_poly_0x04c11db7< 0xFFFFFFFFU, 0xFFFFFFFFU, false > crc32_bzip2
 
typedef crc32_poly_0x1edc6f41< 0xFFFFFFFFU, 0xFFFFFFFFU, true > crc32_c
 
typedef crc32_poly_0x04c11db7< 0xFFFFFFFFU, 0x00000000U, false > crc32_mpeg2
 
typedef crc32_poly_0x04c11db7< 0x00000000U, 0xFFFFFFFFU, false > crc32_posix
 
typedef crc64_poly_0x42f0e1eba9ea3693< 0x0000000000000000U, 0x0000000000000000U, false > crc64_ecma
 
typedef crc8_poly_0x07< 0x00U, 0x00U, false > crc8_ccitt
 
typedef crc8_poly_0x07< 0xFF, 0x00, true > crc8_rohc
 
typedef etl::basic_format_spec< etl::istringformat_spec
 
typedef uint_least8_t fsm_state_id_t
 Allow alternative type for state id.
 
typedef etl::larger_type< etl::message_id_t >::type fsm_internal_id_t
 
typedef integral_constant< bool, false > false_type
 integral_constant specialisations
 
typedef integral_constant< bool, true > true_type
 
typedef hash_finalised hash_finalized
 For the Americans.
 
typedef uint_least8_t message_id_t
 Allow alternative type for message id.
 
typedef uint_least8_t message_router_id_t
 
typedef ratio< 1, 1000000000 > nano
 
typedef ratio< 1, 1000000 > micro
 
typedef ratio< 1, 1000 > milli
 
typedef ratio< 1, 100 > centi
 
typedef ratio< 1, 10 > deci
 
typedef ratio< 10, 1 > deca
 
typedef ratio< 100, 1 > hecto
 
typedef ratio< 1000, 1 > kilo
 
typedef ratio< 1000000, 1 > mega
 
typedef ratio< 1000000000, 1 > giga
 
typedef ratio< 355, 113 > ratio_pi
 An approximation of PI to 6 digits.
 
typedef ratio< 239, 169 > ratio_root2
 An approximation of root 2.
 
typedef ratio< 326, 120 > ratio_e
 An approximation of e.
 
typedef etl::ibasic_string< char > istring
 
typedef etl::basic_string_stream< etl::format_spec, etl::istring, etl::string_viewstring_stream
 
typedef etl::basic_string_view< char > string_view
 
typedef etl::basic_string_view< wchar_t > wstring_view
 
typedef etl::basic_string_view< char16_t > u16string_view
 
typedef etl::basic_string_view< char32_t > u32string_view
 
typedef uint_least8_t task_priority_t
 
typedef etl::atomic_uint32_t timer_semaphore_t
 
typedef etl::basic_format_spec< etl::iu16stringu16format_spec
 
typedef ibasic_string< char16_t > iu16string
 
typedef etl::basic_string_stream< etl::u16format_spec, etl::iu16string, etl::u16string_viewu16string_stream
 
typedef etl::basic_format_spec< etl::iu32stringu32format_spec
 
typedef ibasic_string< char32_t > iu32string
 
typedef etl::basic_string_stream< etl::u32format_spec, etl::iu32string, etl::u32string_viewu32string_stream
 
typedef etl::basic_format_spec< etl::iwstringwformat_spec
 
typedef ibasic_string< wchar_t > iwstring
 
typedef etl::basic_string_stream< etl::wformat_spec, etl::iwstring, etl::wstring_viewwstring_stream
 

Enumerations

enum  memory_order {
  memory_order_relaxed = std::memory_order_relaxed , memory_order_consume = std::memory_order_consume , memory_order_acquire = std::memory_order_acquire , memory_order_release = std::memory_order_release ,
  memory_order_acq_rel = std::memory_order_acq_rel , memory_order_seq_cst = std::memory_order_seq_cst
}
 
enum  binary_constant {
  b00000000 = 0 , b00000001 = 1 , b00000010 = 2 , b00000011 = 3 ,
  b00000100 = 4 , b00000101 = 5 , b00000110 = 6 , b00000111 = 7 ,
  b00001000 = 8 , b00001001 = 9 , b00001010 = 10 , b00001011 = 11 ,
  b00001100 = 12 , b00001101 = 13 , b00001110 = 14 , b00001111 = 15 ,
  b00010000 = 16 , b00010001 = 17 , b00010010 = 18 , b00010011 = 19 ,
  b00010100 = 20 , b00010101 = 21 , b00010110 = 22 , b00010111 = 23 ,
  b00011000 = 24 , b00011001 = 25 , b00011010 = 26 , b00011011 = 27 ,
  b00011100 = 28 , b00011101 = 29 , b00011110 = 30 , b00011111 = 31 ,
  b00100000 = 32 , b00100001 = 33 , b00100010 = 34 , b00100011 = 35 ,
  b00100100 = 36 , b00100101 = 37 , b00100110 = 38 , b00100111 = 39 ,
  b00101000 = 40 , b00101001 = 41 , b00101010 = 42 , b00101011 = 43 ,
  b00101100 = 44 , b00101101 = 45 , b00101110 = 46 , b00101111 = 47 ,
  b00110000 = 48 , b00110001 = 49 , b00110010 = 50 , b00110011 = 51 ,
  b00110100 = 52 , b00110101 = 53 , b00110110 = 54 , b00110111 = 55 ,
  b00111000 = 56 , b00111001 = 57 , b00111010 = 58 , b00111011 = 59 ,
  b00111100 = 60 , b00111101 = 61 , b00111110 = 62 , b00111111 = 63 ,
  b01000000 = 64 , b01000001 = 65 , b01000010 = 66 , b01000011 = 67 ,
  b01000100 = 68 , b01000101 = 69 , b01000110 = 70 , b01000111 = 71 ,
  b01001000 = 72 , b01001001 = 73 , b01001010 = 74 , b01001011 = 75 ,
  b01001100 = 76 , b01001101 = 77 , b01001110 = 78 , b01001111 = 79 ,
  b01010000 = 80 , b01010001 = 81 , b01010010 = 82 , b01010011 = 83 ,
  b01010100 = 84 , b01010101 = 85 , b01010110 = 86 , b01010111 = 87 ,
  b01011000 = 88 , b01011001 = 89 , b01011010 = 90 , b01011011 = 91 ,
  b01011100 = 92 , b01011101 = 93 , b01011110 = 94 , b01011111 = 95 ,
  b01100000 = 96 , b01100001 = 97 , b01100010 = 98 , b01100011 = 99 ,
  b01100100 = 100 , b01100101 = 101 , b01100110 = 102 , b01100111 = 103 ,
  b01101000 = 104 , b01101001 = 105 , b01101010 = 106 , b01101011 = 107 ,
  b01101100 = 108 , b01101101 = 109 , b01101110 = 110 , b01101111 = 111 ,
  b01110000 = 112 , b01110001 = 113 , b01110010 = 114 , b01110011 = 115 ,
  b01110100 = 116 , b01110101 = 117 , b01110110 = 118 , b01110111 = 119 ,
  b01111000 = 120 , b01111001 = 121 , b01111010 = 122 , b01111011 = 123 ,
  b01111100 = 124 , b01111101 = 125 , b01111110 = 126 , b01111111 = 127 ,
  b10000000 = 128 , b10000001 = 129 , b10000010 = 130 , b10000011 = 131 ,
  b10000100 = 132 , b10000101 = 133 , b10000110 = 134 , b10000111 = 135 ,
  b10001000 = 136 , b10001001 = 137 , b10001010 = 138 , b10001011 = 139 ,
  b10001100 = 140 , b10001101 = 141 , b10001110 = 142 , b10001111 = 143 ,
  b10010000 = 144 , b10010001 = 145 , b10010010 = 146 , b10010011 = 147 ,
  b10010100 = 148 , b10010101 = 149 , b10010110 = 150 , b10010111 = 151 ,
  b10011000 = 152 , b10011001 = 153 , b10011010 = 154 , b10011011 = 155 ,
  b10011100 = 156 , b10011101 = 157 , b10011110 = 158 , b10011111 = 159 ,
  b10100000 = 160 , b10100001 = 161 , b10100010 = 162 , b10100011 = 163 ,
  b10100100 = 164 , b10100101 = 165 , b10100110 = 166 , b10100111 = 167 ,
  b10101000 = 168 , b10101001 = 169 , b10101010 = 170 , b10101011 = 171 ,
  b10101100 = 172 , b10101101 = 173 , b10101110 = 174 , b10101111 = 175 ,
  b10110000 = 176 , b10110001 = 177 , b10110010 = 178 , b10110011 = 179 ,
  b10110100 = 180 , b10110101 = 181 , b10110110 = 182 , b10110111 = 183 ,
  b10111000 = 184 , b10111001 = 185 , b10111010 = 186 , b10111011 = 187 ,
  b10111100 = 188 , b10111101 = 189 , b10111110 = 190 , b10111111 = 191 ,
  b11000000 = 192 , b11000001 = 193 , b11000010 = 194 , b11000011 = 195 ,
  b11000100 = 196 , b11000101 = 197 , b11000110 = 198 , b11000111 = 199 ,
  b11001000 = 200 , b11001001 = 201 , b11001010 = 202 , b11001011 = 203 ,
  b11001100 = 204 , b11001101 = 205 , b11001110 = 206 , b11001111 = 207 ,
  b11010000 = 208 , b11010001 = 209 , b11010010 = 210 , b11010011 = 211 ,
  b11010100 = 212 , b11010101 = 213 , b11010110 = 214 , b11010111 = 215 ,
  b11011000 = 216 , b11011001 = 217 , b11011010 = 218 , b11011011 = 219 ,
  b11011100 = 220 , b11011101 = 221 , b11011110 = 222 , b11011111 = 223 ,
  b11100000 = 224 , b11100001 = 225 , b11100010 = 226 , b11100011 = 227 ,
  b11100100 = 228 , b11100101 = 229 , b11100110 = 230 , b11100111 = 231 ,
  b11101000 = 232 , b11101001 = 233 , b11101010 = 234 , b11101011 = 235 ,
  b11101100 = 236 , b11101101 = 237 , b11101110 = 238 , b11101111 = 239 ,
  b11110000 = 240 , b11110001 = 241 , b11110010 = 242 , b11110011 = 243 ,
  b11110100 = 244 , b11110101 = 245 , b11110110 = 246 , b11110111 = 247 ,
  b11111000 = 248 , b11111001 = 249 , b11111010 = 250 , b11111011 = 251 ,
  b11111100 = 252 , b11111101 = 253 , b11111110 = 254 , b11111111 = 255
}
 
enum  bit_constant {
  b0 = 0x1 , b1 = 0x2 , b2 = 0x4 , b3 = 0x8 ,
  b4 = 0x10 , b5 = 0x20 , b6 = 0x40 , b7 = 0x80 ,
  b8 = 0x100 , b9 = 0x200 , b10 = 0x400 , b11 = 0x800 ,
  b12 = 0x1000 , b13 = 0x2000 , b14 = 0x4000 , b15 = 0x8000 ,
  b16 = 0x10000 , b17 = 0x20000 , b18 = 0x40000 , b19 = 0x80000 ,
  b20 = 0x100000 , b21 = 0x200000 , b22 = 0x400000 , b23 = 0x800000 ,
  b24 = 0x1000000 , b25 = 0x2000000 , b26 = 0x4000000 , b27 = 0x8000000 ,
  b28 = 0x10000000 , b29 = 0x20000000 , b30 = 0x40000000 , b31 = 0x80000000
}
 
enum  float_round_style {
  round_indeterminate = std::round_indeterminate , round_toward_zero = std::round_toward_zero , round_to_nearest = std::round_to_nearest , round_toward_infinity = std::round_toward_infinity ,
  round_toward_neg_infinity = std::round_toward_neg_infinity
}
 
enum  float_denorm_style { denorm_indeterminate = std::denorm_indeterminate , denorm_absent = std::denorm_absent , denorm_present = std::denorm_present }
 

Functions

template<typename T >
ETL_CONSTEXPR etl::enable_if< etl::is_signed< T >::value, T >::type absolute (T value)
 
template<typename T >
ETL_CONSTEXPR etl::enable_if< etl::is_unsigned< T >::value, T >::type absolute (T value)
 
template<typename TIterator >
void shell_sort (TIterator first, TIterator last)
 
template<typename TIterator , typename TCompare >
void shell_sort (TIterator first, TIterator last, TCompare compare)
 
template<typename TIterator >
void insertion_sort (TIterator first, TIterator last)
 
template<typename TIterator , typename TCompare >
void insertion_sort (TIterator first, TIterator last, TCompare compare)
 
template<typename TIterator1 , typename TIterator2 >
void iter_swap (TIterator1 a, TIterator2 b)
 
template<typename T1terator1 , typename TIterator2 >
TIterator2 swap_ranges (T1terator1 first1, T1terator1 last1, TIterator2 first2)
 
template<typename TIterator1 , typename TIterator2 >
TIterator2 copy (TIterator1 sb, TIterator1 se, TIterator2 db)
 
template<typename TIterator1 , typename TIterator2 >
TIterator2 reverse_copy (TIterator1 sb, TIterator1 se, TIterator2 db)
 
template<typename TIterator1 , typename TSize , typename TIterator2 >
etl::enable_if< etl::is_pointer< TIterator1 >::value &&etl::is_pointer< TIterator2 >::value &&etl::is_trivially_copyable< typename etl::iterator_traits< TIterator1 >::value_type >::value, TIterator2 >::type copy_n (TIterator1 sb, TSize count, TIterator2 db)
 
template<typename TIterator1 , typename TSize , typename TIterator2 >
etl::enable_if<!etl::is_pointer< TIterator1 >::value||!etl::is_pointer< TIterator2 >::value||!etl::is_trivially_copyable< typename etl::iterator_traits< TIterator1 >::value_type >::value, TIterator2 >::type copy_n (TIterator1 sb, TSize count, TIterator2 db)
 
template<typename TIterator1 , typename TIterator2 >
TIterator2 copy_backward (TIterator1 sb, TIterator1 se, TIterator2 de)
 
template<typename TIterator1 , typename TIterator2 >
TIterator2 move (TIterator1 sb, TIterator1 se, TIterator2 db)
 
template<typename TIterator1 , typename TIterator2 >
TIterator2 move_backward (TIterator1 sb, TIterator1 se, TIterator2 de)
 
template<typename TIterator >
void reverse (TIterator b, TIterator e)
 
template<typename TIterator , typename TValue , typename TCompare >
ETL_NODISCARD TIterator lower_bound (TIterator first, TIterator last, const TValue &value, TCompare compare)
 
template<typename TIterator , typename TValue >
ETL_NODISCARD TIterator lower_bound (TIterator first, TIterator last, const TValue &value)
 
template<typename TIterator , typename TValue , typename TCompare >
ETL_NODISCARD TIterator upper_bound (TIterator first, TIterator last, const TValue &value, TCompare compare)
 
template<typename TIterator , typename TValue >
ETL_NODISCARD TIterator upper_bound (TIterator first, TIterator last, const TValue &value)
 
template<typename TIterator , typename TValue , typename TCompare >
ETL_NODISCARD std::pair< TIterator, TIterator > equal_range (TIterator first, TIterator last, const TValue &value, TCompare compare)
 
template<typename TIterator , typename TValue >
ETL_NODISCARD std::pair< TIterator, TIterator > equal_range (TIterator first, TIterator last, const TValue &value)
 
template<typename TIterator , typename TUnaryPredicate >
ETL_NODISCARD TIterator find_if (TIterator first, TIterator last, TUnaryPredicate predicate)
 
template<typename TIterator , typename T >
ETL_NODISCARD TIterator find (TIterator first, TIterator last, const T &value)
 
template<typename TIterator , typename TValue >
void fill (TIterator first, TIterator last, const TValue &value)
 
template<typename TIterator , typename TSize , typename TValue >
TIterator fill_n (TIterator first, TSize count, const TValue &value)
 
template<typename TIterator , typename T >
ETL_NODISCARD std::iterator_traits< TIterator >::difference_type count (TIterator first, TIterator last, const T &value)
 
template<typename TIterator , typename TUnaryPredicate >
ETL_NODISCARD std::iterator_traits< TIterator >::difference_type count_if (TIterator first, TIterator last, TUnaryPredicate predicate)
 
template<typename TIterator1 , typename TIterator2 >
ETL_NODISCARD bool equal (TIterator1 first1, TIterator1 last1, TIterator2 first2)
 
template<typename TIterator1 , typename TIterator2 >
ETL_NODISCARD bool equal (TIterator1 first1, TIterator1 last1, TIterator2 first2, TIterator2 last2)
 
template<typename TIterator1 , typename TIterator2 , typename TCompare >
ETL_NODISCARD bool lexicographical_compare (TIterator1 first1, TIterator1 last1, TIterator2 first2, TIterator2 last2, TCompare compare)
 
template<typename TIterator1 , typename TIterator2 >
ETL_NODISCARD bool lexicographical_compare (TIterator1 first1, TIterator1 last1, TIterator2 first2, TIterator2 last2)
 
template<typename T , typename TCompare >
ETL_NODISCARD ETL_CONSTEXPR const T & min (const T &a, const T &b, TCompare compare)
 
template<typename T >
ETL_NODISCARD ETL_CONSTEXPR const T & min (const T &a, const T &b)
 
template<typename T , typename TCompare >
ETL_NODISCARD ETL_CONSTEXPR const T & max (const T &a, const T &b, TCompare compare)
 
template<typename T >
ETL_NODISCARD ETL_CONSTEXPR const T & max (const T &a, const T &b)
 
template<typename TIteratorIn , typename TIteratorOut , typename TUnaryOperation >
TIteratorOut transform (TIteratorIn first1, TIteratorIn last1, TIteratorOut d_first, TUnaryOperation unary_operation)
 
template<typename TIteratorIn1 , typename TIteratorIn2 , typename TIteratorOut , typename TBinaryOperation >
TIteratorOut transform (TIteratorIn1 first1, TIteratorIn1 last1, TIteratorIn2 first2, TIteratorOut d_first, TBinaryOperation binary_operation)
 
template<typename TIterator , typename T >
ETL_CONSTEXPR14 void replace (TIterator first, TIterator last, const T &old_value, const T &new_value)
 
template<typename TIterator , typename TPredicate , typename T >
ETL_CONSTEXPR14 void replace_if (TIterator first, TIterator last, TPredicate predicate, const T &new_value)
 
template<typename TIterator , typename TCompare >
void pop_heap (TIterator first, TIterator last, TCompare compare)
 
template<typename TIterator >
void pop_heap (TIterator first, TIterator last)
 
template<typename TIterator , typename TCompare >
void push_heap (TIterator first, TIterator last, TCompare compare)
 
template<typename TIterator >
void push_heap (TIterator first, TIterator last)
 
template<typename TIterator , typename TCompare >
void make_heap (TIterator first, TIterator last, TCompare compare)
 
template<typename TIterator >
void make_heap (TIterator first, TIterator last)
 
template<typename TIterator , typename TCompare >
ETL_NODISCARD bool is_heap (TIterator first, TIterator last, TCompare compare)
 
template<typename TIterator >
ETL_NODISCARD bool is_heap (TIterator first, TIterator last)
 
template<typename TIterator , typename TCompare >
void sort_heap (TIterator first, TIterator last, TCompare compare)
 
template<typename TIterator >
void sort_heap (TIterator first, TIterator last)
 
template<typename TIterator1 , typename TIterator2 , typename TCompare >
ETL_NODISCARD TIterator1 search (TIterator1 first, TIterator1 last, TIterator2 search_first, TIterator2 search_last, TCompare compare)
 
template<typename TIterator1 , typename TIterator2 >
ETL_NODISCARD TIterator1 search (TIterator1 first, TIterator1 last, TIterator2 search_first, TIterator2 search_last)
 
template<typename TIterator >
TIterator rotate (TIterator first, TIterator middle, TIterator last)
 
template<typename TIterator1 , typename TIterator2 , typename TPredicate >
ETL_NODISCARD TIterator1 find_end (TIterator1 b, TIterator1 e, TIterator2 sb, TIterator2 se, TPredicate predicate)
 
template<typename TIterator1 , typename TIterator2 >
ETL_NODISCARD TIterator1 find_end (TIterator1 b, TIterator1 e, TIterator2 sb, TIterator2 se)
 
template<typename TIterator , typename TCompare >
ETL_NODISCARD TIterator min_element (TIterator begin, TIterator end, TCompare compare)
 
template<typename TIterator >
ETL_NODISCARD TIterator min_element (TIterator begin, TIterator end)
 
template<typename TIterator , typename TCompare >
ETL_NODISCARD TIterator max_element (TIterator begin, TIterator end, TCompare compare)
 
template<typename TIterator >
ETL_NODISCARD TIterator max_element (TIterator begin, TIterator end)
 
template<typename TIterator , typename TCompare >
ETL_NODISCARD ETL_OR_STD::pair< TIterator, TIterator > minmax_element (TIterator begin, TIterator end, TCompare compare)
 
template<typename TIterator >
ETL_NODISCARD ETL_OR_STD::pair< TIterator, TIterator > minmax_element (TIterator begin, TIterator end)
 
template<typename T >
ETL_NODISCARD ETL_OR_STD::pair< const T &, const T & > minmax (const T &a, const T &b)
 
template<typename T , typename TCompare >
ETL_NODISCARD ETL_OR_STD::pair< const T &, const T & > minmax (const T &a, const T &b, TCompare compare)
 
template<typename TIterator >
ETL_NODISCARD TIterator is_sorted_until (TIterator begin, TIterator end)
 
template<typename TIterator , typename TCompare >
ETL_NODISCARD TIterator is_sorted_until (TIterator begin, TIterator end, TCompare compare)
 
template<typename TIterator >
ETL_NODISCARD bool is_sorted (TIterator begin, TIterator end)
 
template<typename TIterator , typename TCompare >
ETL_NODISCARD bool is_sorted (TIterator begin, TIterator end, TCompare compare)
 
template<typename TIterator , typename TUnaryPredicate >
ETL_NODISCARD TIterator find_if_not (TIterator begin, TIterator end, TUnaryPredicate predicate)
 
template<typename TIterator1 , typename TIterator2 >
ETL_NODISCARD bool is_permutation (TIterator1 begin1, TIterator1 end1, TIterator2 begin2)
 
template<typename TIterator1 , typename TIterator2 , typename TBinaryPredicate >
ETL_NODISCARD bool is_permutation (TIterator1 begin1, TIterator1 end1, TIterator2 begin2, TBinaryPredicate predicate)
 
template<typename TIterator1 , typename TIterator2 >
ETL_NODISCARD bool is_permutation (TIterator1 begin1, TIterator1 end1, TIterator2 begin2, TIterator2 end2)
 
template<typename TIterator1 , typename TIterator2 , typename TBinaryPredicate >
ETL_NODISCARD bool is_permutation (TIterator1 begin1, TIterator1 end1, TIterator2 begin2, TIterator2 end2, TBinaryPredicate predicate)
 
template<typename TIterator , typename TUnaryPredicate >
ETL_NODISCARD bool is_partitioned (TIterator begin, TIterator end, TUnaryPredicate predicate)
 
template<typename TIterator , typename TUnaryPredicate >
ETL_NODISCARD TIterator partition_point (TIterator begin, TIterator end, TUnaryPredicate predicate)
 
template<typename TSource , typename TDestinationTrue , typename TDestinationFalse , typename TUnaryPredicate >
ETL_OR_STD::pair< TDestinationTrue, TDestinationFalse > partition_copy (TSource begin, TSource end, TDestinationTrue destination_true, TDestinationFalse destination_false, TUnaryPredicate predicate)
 
template<typename TIterator , typename TOutputIterator , typename TUnaryPredicate >
TOutputIterator copy_if (TIterator begin, TIterator end, TOutputIterator out, TUnaryPredicate predicate)
 
template<typename TIterator , typename TUnaryPredicate >
ETL_NODISCARD bool all_of (TIterator begin, TIterator end, TUnaryPredicate predicate)
 
template<typename TIterator , typename TUnaryPredicate >
ETL_NODISCARD bool any_of (TIterator begin, TIterator end, TUnaryPredicate predicate)
 
template<typename TIterator , typename TUnaryPredicate >
ETL_NODISCARD bool none_of (TIterator begin, TIterator end, TUnaryPredicate predicate)
 
template<typename TIterator , typename TCompare >
void sort (TIterator first, TIterator last, TCompare compare)
 
template<typename TIterator >
void sort (TIterator first, TIterator last)
 
template<typename TIterator , typename TCompare >
void stable_sort (TIterator first, TIterator last, TCompare compare)
 
template<typename TIterator >
void stable_sort (TIterator first, TIterator last)
 
template<typename TInputIterator , typename TOutputIterator >
etl::enable_if< etl::is_random_iterator< TInputIterator >::value &&etl::is_random_iterator< TOutputIterator >::value, TOutputIterator >::type copy_s (TInputIterator i_begin, TInputIterator i_end, TOutputIterator o_begin, TOutputIterator o_end)
 
template<typename TInputIterator , typename TOutputIterator >
etl::enable_if<!etl::is_random_iterator< TInputIterator >::value||!etl::is_random_iterator< TOutputIterator >::value, TOutputIterator >::type copy_s (TInputIterator i_begin, TInputIterator i_end, TOutputIterator o_begin, TOutputIterator o_end)
 
template<typename TInputIterator , typename TSize , typename TOutputIterator >
TOutputIterator copy_n_s (TInputIterator i_begin, TSize n, TOutputIterator o_begin, TOutputIterator o_end)
 
template<typename TInputIterator , typename TSize1 , typename TOutputIterator , typename TSize2 >
TOutputIterator copy_n_s (TInputIterator i_begin, TSize1 n1, TOutputIterator o_begin, TSize2 n2)
 
template<typename TInputIterator , typename TOutputIterator , typename TUnaryPredicate >
TOutputIterator copy_if_s (TInputIterator i_begin, TInputIterator i_end, TOutputIterator o_begin, TOutputIterator o_end, TUnaryPredicate predicate)
 
template<typename TInputIterator , typename TSize , typename TOutputIterator , typename TUnaryPredicate >
TOutputIterator copy_n_if (TInputIterator i_begin, TSize n, TOutputIterator o_begin, TUnaryPredicate predicate)
 
template<typename TInputIterator , typename TOutputIterator >
TOutputIterator move_s (TInputIterator i_begin, TInputIterator i_end, TOutputIterator o_begin, TOutputIterator o_end)
 
template<typename TIterator , typename TValue >
ETL_NODISCARD TIterator binary_find (TIterator begin, TIterator end, const TValue &value)
 
template<typename TIterator , typename TValue , typename TBinaryPredicate , typename TBinaryEquality >
ETL_NODISCARD TIterator binary_find (TIterator begin, TIterator end, const TValue &value, TBinaryPredicate predicate, TBinaryEquality equality)
 
template<typename TIterator , typename TUnaryFunction , typename TUnaryPredicate >
TUnaryFunction for_each_if (TIterator begin, const TIterator end, TUnaryFunction function, TUnaryPredicate predicate)
 
template<typename TIterator , typename TSize , typename TUnaryFunction >
TIterator for_each_n (TIterator begin, TSize n, TUnaryFunction function)
 
template<typename TIterator , typename TSize , typename TUnaryFunction , typename TUnaryPredicate >
TIterator for_each_n_if (TIterator begin, TSize n, TUnaryFunction function, TUnaryPredicate predicate)
 
template<typename TInputIterator , typename TOutputIterator , typename TUnaryFunction >
TOutputIterator transform_s (TInputIterator i_begin, TInputIterator i_end, TOutputIterator o_begin, TOutputIterator o_end, TUnaryFunction function)
 
template<typename TInputIterator , typename TSize , typename TOutputIterator , typename TUnaryFunction >
void transform_n (TInputIterator i_begin, TSize n, TOutputIterator o_begin, TUnaryFunction function)
 
template<typename TInputIterator1 , typename TInputIterator2 , typename TSize , typename TOutputIterator , typename TBinaryFunction >
void transform_n (TInputIterator1 i_begin1, TInputIterator2 i_begin2, TSize n, TOutputIterator o_begin, TBinaryFunction function)
 
template<typename TInputIterator , typename TOutputIterator , typename TUnaryFunction , typename TUnaryPredicate >
TOutputIterator transform_if (TInputIterator i_begin, const TInputIterator i_end, TOutputIterator o_begin, TUnaryFunction function, TUnaryPredicate predicate)
 
template<typename TInputIterator1 , typename TInputIterator2 , typename TOutputIterator , typename TBinaryFunction , typename TBinaryPredicate >
TOutputIterator transform_if (TInputIterator1 i_begin1, const TInputIterator1 i_end1, TInputIterator2 i_begin2, TOutputIterator o_begin, TBinaryFunction function, TBinaryPredicate predicate)
 
template<typename TInputIterator , typename TSize , typename TOutputIterator , typename TUnaryFunction , typename TUnaryPredicate >
TOutputIterator transform_n_if (TInputIterator i_begin, TSize n, TOutputIterator o_begin, TUnaryFunction function, TUnaryPredicate predicate)
 
template<typename TInputIterator1 , typename TInputIterator2 , typename TSize , typename TOutputIterator , typename TBinaryFunction , typename TBinaryPredicate >
TOutputIterator transform_n_if (TInputIterator1 i_begin1, TInputIterator2 i_begin2, TSize n, TOutputIterator o_begin, TBinaryFunction function, TBinaryPredicate predicate)
 
template<typename TSource , typename TDestinationTrue , typename TDestinationFalse , typename TUnaryFunctionTrue , typename TUnaryFunctionFalse , typename TUnaryPredicate >
ETL_OR_STD::pair< TDestinationTrue, TDestinationFalse > partition_transform (TSource begin, TSource end, TDestinationTrue destination_true, TDestinationFalse destination_false, TUnaryFunctionTrue function_true, TUnaryFunctionFalse function_false, TUnaryPredicate predicate)
 
template<typename TSource1 , typename TSource2 , typename TDestinationTrue , typename TDestinationFalse , typename TBinaryFunctionTrue , typename TBinaryFunctionFalse , typename TBinaryPredicate >
ETL_OR_STD::pair< TDestinationTrue, TDestinationFalse > partition_transform (TSource1 begin1, TSource1 end1, TSource2 begin2, TDestinationTrue destination_true, TDestinationFalse destination_false, TBinaryFunctionTrue function_true, TBinaryFunctionFalse function_false, TBinaryPredicate predicate)
 
template<typename TIterator , typename TCompare >
void heap_sort (TIterator first, TIterator last, TCompare compare)
 
template<typename TIterator >
void heap_sort (TIterator first, TIterator last)
 
template<typename T , const size_t SIZE>
void swap (etl::array< T, SIZE > &lhs, etl::array< T, SIZE > &rhs)
 Template deduction guides. More...
 
template<typename T , size_t SIZE>
bool operator== (const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
 
template<typename T , size_t SIZE>
bool operator!= (const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
 
template<typename T , size_t SIZE>
bool operator< (const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
 
template<typename T , size_t SIZE>
bool operator<= (const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
 
template<typename T , size_t SIZE>
bool operator> (const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
 
template<typename T , size_t SIZE>
bool operator>= (const etl::array< T, SIZE > &lhs, const etl::array< T, SIZE > &rhs)
 
template<size_t I, typename T , size_t MAXN>
T & get (array< T, MAXN > &a)
 
template<size_t I, typename T , size_t MAXN>
const T & get (const array< T, MAXN > &a)
 
template<typename TL , typename TR , size_t SIZEL, size_t SIZER, TL(&) ARRAYL, TR(&) ARRAYR>
bool operator== (const etl::array_wrapper< TL, SIZEL, ARRAYL > &lhs, const etl::array_wrapper< TR, SIZER, ARRAYR > &rhs)
 Equality for array wrappers.
 
template<typename TL , typename TR , size_t SIZEL, size_t SIZER, TL(&) ARRAYL, TR(&) ARRAYR>
bool operator!= (const etl::array_wrapper< TL, SIZEL, ARRAYL > &lhs, const etl::array_wrapper< TR, SIZER, ARRAYR > &rhs)
 Inequality for array wrapper.
 
template<typename TL , typename TR , size_t SIZEL, size_t SIZER, TL(&) ARRAYL, TR(&) ARRAYR>
bool operator< (const etl::array_wrapper< TL, SIZEL, ARRAYL > &lhs, const etl::array_wrapper< TR, SIZER, ARRAYR > &rhs)
 Less-than for array wrapper.
 
template<typename TL , typename TR , size_t SIZEL, size_t SIZER, TL(&) ARRAYL, TR(&) ARRAYR>
bool operator> (const etl::array_wrapper< TL, SIZEL, ARRAYL > &lhs, const etl::array_wrapper< TR, SIZER, ARRAYR > &rhs)
 Greater-than for array wrapper.
 
template<typename TL , typename TR , size_t SIZEL, size_t SIZER, TL(&) ARRAYL, TR(&) ARRAYR>
bool operator<= (const etl::array_wrapper< TL, SIZEL, ARRAYL > &lhs, const etl::array_wrapper< TR, SIZER, ARRAYR > &rhs)
 Less-than-equal for array wrapper.
 
template<typename TL , typename TR , size_t SIZEL, size_t SIZER, TL(&) ARRAYL, TR(&) ARRAYR>
bool operator>= (const etl::array_wrapper< TL, SIZEL, ARRAYL > &lhs, const etl::array_wrapper< TR, SIZER, ARRAYR > &rhs)
 Greater-than-equal for array wrapper.
 
template<typename T >
bool operator== (const etl::ibasic_string< T > &lhs, const etl::ibasic_string< T > &rhs)
 
template<typename T >
bool operator== (const etl::ibasic_string< T > &lhs, const T *rhs)
 
template<typename T >
bool operator== (const T *lhs, const etl::ibasic_string< T > &rhs)
 
template<typename T >
bool operator!= (const etl::ibasic_string< T > &lhs, const etl::ibasic_string< T > &rhs)
 
template<typename T >
bool operator!= (const etl::ibasic_string< T > &lhs, const T *rhs)
 
template<typename T >
bool operator!= (const T *lhs, const etl::ibasic_string< T > &rhs)
 
template<typename T >
bool operator< (const etl::ibasic_string< T > &lhs, const etl::ibasic_string< T > &rhs)
 
template<typename T >
bool operator< (const etl::ibasic_string< T > &lhs, const T *rhs)
 
template<typename T >
bool operator< (const T *lhs, const etl::ibasic_string< T > &rhs)
 
template<typename T >
bool operator> (const etl::ibasic_string< T > &lhs, const etl::ibasic_string< T > &rhs)
 
template<typename T >
bool operator> (const etl::ibasic_string< T > &lhs, const T *rhs)
 
template<typename T >
bool operator> (const T *lhs, const etl::ibasic_string< T > &rhs)
 
template<typename T >
bool operator<= (const etl::ibasic_string< T > &lhs, const etl::ibasic_string< T > &rhs)
 
template<typename T >
bool operator<= (const etl::ibasic_string< T > &lhs, const T *rhs)
 
template<typename T >
bool operator<= (const T *lhs, const etl::ibasic_string< T > &rhs)
 
template<typename T >
bool operator>= (const etl::ibasic_string< T > &lhs, const etl::ibasic_string< T > &rhs)
 
template<typename T >
bool operator>= (const etl::ibasic_string< T > &lhs, const T *rhs)
 
template<typename T >
bool operator>= (const T *lhs, const etl::ibasic_string< T > &rhs)
 
template<typename T >
ETL_CONSTEXPR14 T rotate_left (T value)
 
template<typename T >
ETL_CONSTEXPR14 T rotate_left (T value, size_t distance)
 
template<typename T >
ETL_CONSTEXPR14 T rotate_right (T value)
 
template<typename T >
ETL_CONSTEXPR14 T rotate_right (T value, size_t distance)
 
template<typename T >
ETL_CONSTEXPR14 T rotate (T value, typename etl::make_signed< size_t >::type distance)
 
template<typename T >
ETL_CONSTEXPR T binary_to_gray (T value)
 
template<typename TReturn , const size_t NBITS, typename TValue >
ETL_CONSTEXPR14 TReturn fold_bits (TValue value)
 
template<typename TReturn , const size_t NBITS, typename TValue >
ETL_CONSTEXPR14 TReturn sign_extend (TValue value)
 
template<typename TReturn , const size_t NBITS, const size_t SHIFT, typename TValue >
ETL_CONSTEXPR14 TReturn sign_extend (TValue value)
 
template<typename TReturn , typename TValue >
ETL_CONSTEXPR14 TReturn sign_extend (TValue value, const size_t NBITS)
 
template<typename TReturn , typename TValue >
ETL_CONSTEXPR14 TReturn sign_extend (TValue value, const size_t NBITS, const size_t SHIFT)
 
template<typename T >
ETL_CONSTEXPR14 uint_least8_t first_set_bit_position (T value)
 
template<typename T >
ETL_CONSTEXPR14 uint_least8_t first_clear_bit_position (T value)
 
template<typename T >
ETL_CONSTEXPR14 uint_least8_t first_bit_position (bool state, T value)
 
template<typename TResult , typename TValue >
ETL_CONSTEXPR TResult binary_fill (TValue value)
 
template<typename TResult , typename TValue , const TValue N>
ETL_CONSTEXPR TResult binary_fill ()
 
template<typename T >
ETL_CONSTEXPR T binary_merge (const T first, const T second, const T mask)
 
template<typename T , const T MASK>
ETL_CONSTEXPR T binary_merge (const T first, const T second)
 
ETL_CONSTEXPR14 uint16_t reverse_bits (uint16_t value)
 
ETL_CONSTEXPR14 int16_t reverse_bits (int16_t value)
 
ETL_CONSTEXPR14 uint32_t reverse_bits (uint32_t value)
 
ETL_CONSTEXPR14 int32_t reverse_bits (int32_t value)
 
ETL_CONSTEXPR14 uint64_t reverse_bits (uint64_t value)
 
ETL_CONSTEXPR14 int64_t reverse_bits (int64_t value)
 
ETL_CONSTEXPR uint16_t reverse_bytes (uint16_t value)
 
ETL_CONSTEXPR int16_t reverse_bytes (int16_t value)
 
ETL_CONSTEXPR14 uint32_t reverse_bytes (uint32_t value)
 
ETL_CONSTEXPR14 int32_t reverse_bytes (int32_t value)
 
ETL_CONSTEXPR14 uint64_t reverse_bytes (uint64_t value)
 
ETL_CONSTEXPR14 int64_t reverse_bytes (int64_t value)
 
ETL_CONSTEXPR14 uint16_t gray_to_binary (uint16_t value)
 
ETL_CONSTEXPR14 int16_t gray_to_binary (int16_t value)
 
ETL_CONSTEXPR14 uint32_t gray_to_binary (uint32_t value)
 
ETL_CONSTEXPR14 int32_t gray_to_binary (int32_t value)
 
ETL_CONSTEXPR14 uint64_t gray_to_binary (uint64_t value)
 
ETL_CONSTEXPR14 int64_t gray_to_binary (int64_t value)
 
ETL_CONSTEXPR14 uint_least8_t count_bits (uint16_t value)
 
ETL_CONSTEXPR14 uint_least8_t count_bits (int16_t value)
 
ETL_CONSTEXPR14 uint_least8_t count_bits (uint32_t value)
 
ETL_CONSTEXPR14 uint_least8_t count_bits (int32_t value)
 
ETL_CONSTEXPR14 uint_least8_t count_bits (uint64_t value)
 
ETL_CONSTEXPR14 uint_least8_t count_bits (int64_t value)
 
ETL_CONSTEXPR14 uint_least8_t parity (uint16_t value)
 
ETL_CONSTEXPR14 uint_least8_t parity (int16_t value)
 
ETL_CONSTEXPR14 uint_least8_t parity (uint32_t value)
 
ETL_CONSTEXPR14 uint_least8_t parity (int32_t value)
 
ETL_CONSTEXPR14 uint_least8_t parity (uint64_t value)
 
ETL_CONSTEXPR14 uint_least8_t parity (int64_t value)
 
ETL_CONSTEXPR14 uint_least8_t count_trailing_zeros (uint16_t value)
 
ETL_CONSTEXPR14 uint_least8_t count_trailing_zeros (int16_t value)
 
ETL_CONSTEXPR14 uint_least8_t count_trailing_zeros (uint32_t value)
 
ETL_CONSTEXPR14 uint_least8_t count_trailing_zeros (int32_t value)
 
ETL_CONSTEXPR14 uint_least8_t count_trailing_zeros (uint64_t value)
 
ETL_CONSTEXPR14 uint_least8_t count_trailing_zeros (int64_t value)
 
ETL_CONSTEXPR14 uint32_t binary_interleave (uint16_t first, uint16_t second)
 
ETL_CONSTEXPR14 int32_t binary_interleave (int16_t first, int16_t second)
 
ETL_CONSTEXPR14 uint64_t binary_interleave (uint32_t first, uint32_t second)
 
ETL_CONSTEXPR14 int64_t binary_interleave (int32_t first, int32_t second)
 
template<typename T >
ETL_CONSTEXPR etl::enable_if< etl::is_integral< T >::value, bool >::type is_odd (const T value)
 
template<typename T >
ETL_CONSTEXPR etl::enable_if< etl::is_integral< T >::value, bool >::type is_even (const T value)
 
template<const size_t MAXN>
bitset< MAXN > operator& (const bitset< MAXN > &lhs, const bitset< MAXN > &rhs)
 
template<const size_t MAXN>
bitset< MAXN > operator| (const bitset< MAXN > &lhs, const bitset< MAXN > &rhs)
 
template<const size_t MAXN>
bitset< MAXN > operator^ (const bitset< MAXN > &lhs, const bitset< MAXN > &rhs)
 
template<const size_t MAXN>
bool operator!= (const bitset< MAXN > &lhs, const bitset< MAXN > &rhs)
 
template<typename T >
size_t strlen (const T *t)
 Alternative strlen for all character types.
 
template<typename T >
void swap (etl::circular_buffer_ext< T > &lhs, etl::circular_buffer_ext< T > &rhs)
 Template deduction guides. More...
 
template<typename T >
bool operator== (const icircular_buffer< T > &lhs, const icircular_buffer< T > &rhs)
 Equality operator.
 
template<typename T >
bool operator!= (const icircular_buffer< T > &lhs, const icircular_buffer< T > &rhs)
 Inequality operator.
 
template<typename TContainer >
ETL_CONSTEXPR TContainer::iterator begin (TContainer &container)
 
template<typename TContainer >
ETL_CONSTEXPR TContainer::const_iterator begin (const TContainer &container)
 
template<typename TContainer >
ETL_CONSTEXPR TContainer::const_iterator cbegin (const TContainer &container)
 
template<typename TContainer >
ETL_CONSTEXPR TContainer::reverse_iterator rbegin (const TContainer &container)
 
template<typename TContainer >
ETL_CONSTEXPR TContainer::reverse_iterator crbegin (const TContainer &container)
 
template<typename TContainer >
ETL_CONSTEXPR TContainer::iterator end (TContainer &container)
 
template<typename TContainer >
ETL_CONSTEXPR TContainer::const_iterator end (const TContainer &container)
 
template<typename TContainer >
ETL_CONSTEXPR TContainer::const_iterator cend (const TContainer &container)
 
template<typename TContainer >
ETL_CONSTEXPR TContainer::const_iterator rend (const TContainer &container)
 
template<typename TContainer >
ETL_CONSTEXPR TContainer::reverse_iterator crend (const TContainer &container)
 
template<typename TValue , const size_t ARRAY_SIZE>
ETL_CONSTEXPR TValue * begin (TValue(&data)[ARRAY_SIZE])
 
template<typename TValue , const size_t ARRAY_SIZE>
ETL_CONSTEXPR const TValue * begin (const TValue(&data)[ARRAY_SIZE])
 
template<typename TValue , const size_t ARRAY_SIZE>
ETL_CONSTEXPR const TValue * cbegin (const TValue(&data)[ARRAY_SIZE])
 
template<typename TValue , const size_t ARRAY_SIZE>
ETL_OR_STD::reverse_iterator< TValue * > rbegin (const TValue(&data)[ARRAY_SIZE])
 
template<typename TValue , const size_t ARRAY_SIZE>
ETL_CONSTEXPR ETL_OR_STD::reverse_iterator< const TValue * > crbegin (const TValue(&data)[ARRAY_SIZE])
 
template<typename TValue , const size_t ARRAY_SIZE>
ETL_CONSTEXPR TValue * end (TValue(&data)[ARRAY_SIZE])
 
template<typename TValue , const size_t ARRAY_SIZE>
ETL_CONSTEXPR const TValue * end (const TValue(&data)[ARRAY_SIZE])
 
template<typename TValue , const size_t ARRAY_SIZE>
ETL_CONSTEXPR const TValue * cend (const TValue(&data)[ARRAY_SIZE])
 
template<typename TValue , const size_t ARRAY_SIZE>
ETL_CONSTEXPR ETL_OR_STD::reverse_iterator< TValue * > rend (const TValue(&data)[ARRAY_SIZE])
 
template<typename TValue , const size_t ARRAY_SIZE>
ETL_CONSTEXPR ETL_OR_STD::reverse_iterator< const TValue * > crend (const TValue(&data)[ARRAY_SIZE])
 
template<typename TContainer >
ETL_CONSTEXPR TContainer::size_type size (const TContainer &container)
 
template<typename TValue , const size_t ARRAY_SIZE>
ETL_CONSTEXPR size_t size (TValue(&)[ARRAY_SIZE])
 
template<typename T , const size_t ARRAY_SIZE>
char(& array_size (T(&array)[ARRAY_SIZE]))[ARRAY_SIZE]
 
template<typename T >
bool operator== (const etl::ideque< T > &lhs, const etl::ideque< T > &rhs)
 Template deduction guides. More...
 
template<typename T >
bool operator!= (const etl::ideque< T > &lhs, const etl::ideque< T > &rhs)
 
template<typename T >
bool operator< (const etl::ideque< T > &lhs, const etl::ideque< T > &rhs)
 
template<typename T >
bool operator<= (const etl::ideque< T > &lhs, const etl::ideque< T > &rhs)
 
template<typename T >
bool operator> (const etl::ideque< T > &lhs, const etl::ideque< T > &rhs)
 
template<typename T >
bool operator>= (const etl::ideque< T > &lhs, const etl::ideque< T > &rhs)
 
uint8_t ntoh (const uint8_t network)
 
uint16_t ntoh (const uint16_t network)
 
uint32_t ntoh (const uint32_t network)
 
uint64_t ntoh (const uint64_t network)
 
uint8_t hton (const uint8_t host)
 
uint16_t hton (const uint16_t host)
 
uint32_t hton (const uint32_t host)
 
uint64_t hton (const uint64_t host)
 
template<typename TIterator >
etl::fixed_iterator< TIterator > & operator+ (etl::fixed_iterator< TIterator > &lhs, typename etl::iterator_traits< TIterator >::difference_type)
 
template<typename TIterator >
etl::fixed_iterator< TIterator > & operator- (etl::fixed_iterator< TIterator > &lhs, typename etl::iterator_traits< TIterator >::difference_type)
 
template<typename TIterator >
etl::iterator_traits< TIterator >::difference_type operator- (etl::fixed_iterator< TIterator > &lhs, etl::fixed_iterator< TIterator > &rhs)
 
template<typename TIterator >
bool operator== (const etl::fixed_iterator< TIterator > &lhs, const etl::fixed_iterator< TIterator > &rhs)
 Equality operator. fixed_iterator == fixed_iterator.
 
template<typename TIterator >
bool operator== (const etl::fixed_iterator< TIterator > &lhs, TIterator rhs)
 Equality operator. fixed_iterator == iterator.
 
template<typename TIterator >
bool operator== (TIterator lhs, const etl::fixed_iterator< TIterator > &rhs)
 Equality operator. iterator == fixed_iterator.
 
template<typename TIterator >
bool operator!= (const etl::fixed_iterator< TIterator > &lhs, const etl::fixed_iterator< TIterator > &rhs)
 Inequality operator. fixed_iterator == fixed_iterator.
 
template<typename TIterator >
bool operator!= (const etl::fixed_iterator< TIterator > &lhs, TIterator rhs)
 Inequality operator. fixed_iterator == iterator.
 
template<typename TIterator >
bool operator!= (TIterator &lhs, const etl::fixed_iterator< TIterator > &rhs)
 Inequality operator. iterator == fixed_iterator.
 
template<typename T , T MASK>
ETL_CONSTEXPR bool operator== (flags< T, MASK > lhs, flags< T, MASK > rhs) ETL_NOEXCEPT
 operator ==
 
template<typename T , T MASK>
ETL_CONSTEXPR bool operator!= (flags< T, MASK > lhs, flags< T, MASK > rhs) ETL_NOEXCEPT
 operator !=
 
template<typename T , T MASK>
void swap (etl::flags< T, MASK > &lhs, etl::flags< T, MASK > &rhs) ETL_NOEXCEPT
 swap
 
template<typename TKey , typename TMapped , typename TKeyCompare >
bool operator== (const etl::iflat_map< TKey, TMapped, TKeyCompare > &lhs, const etl::iflat_map< TKey, TMapped, TKeyCompare > &rhs)
 
template<typename TKey , typename TMapped , typename TKeyCompare >
bool operator!= (const etl::iflat_map< TKey, TMapped, TKeyCompare > &lhs, const etl::iflat_map< TKey, TMapped, TKeyCompare > &rhs)
 
template<typename TKey , typename TMapped , typename TKeyCompare >
bool operator== (const etl::iflat_multimap< TKey, TMapped, TKeyCompare > &lhs, const etl::iflat_multimap< TKey, TMapped, TKeyCompare > &rhs)
 
template<typename TKey , typename TMapped , typename TKeyCompare >
bool operator!= (const etl::iflat_multimap< TKey, TMapped, TKeyCompare > &lhs, const etl::iflat_multimap< TKey, TMapped, TKeyCompare > &rhs)
 
template<typename T , typename TKeyCompare >
bool operator== (const etl::iflat_multiset< T, TKeyCompare > &lhs, const etl::iflat_multiset< T, TKeyCompare > &rhs)
 
template<typename T , typename TKeyCompare >
bool operator!= (const etl::iflat_multiset< T, TKeyCompare > &lhs, const etl::iflat_multiset< T, TKeyCompare > &rhs)
 
template<typename T , typename TKeyCompare >
bool operator== (const etl::iflat_set< T, TKeyCompare > &lhs, const etl::iflat_set< T, TKeyCompare > &rhs)
 
template<typename T , typename TKeyCompare >
bool operator!= (const etl::iflat_set< T, TKeyCompare > &lhs, const etl::iflat_set< T, TKeyCompare > &rhs)
 
template<typename T >
bool operator== (const etl::iforward_list< T > &lhs, const etl::iforward_list< T > &rhs)
 
template<typename T >
bool operator!= (const etl::iforward_list< T > &lhs, const etl::iforward_list< T > &rhs)
 
template<typename T >
bool operator< (const etl::iforward_list< T > &lhs, const etl::iforward_list< T > &rhs)
 
template<typename T >
bool operator> (const etl::iforward_list< T > &lhs, const etl::iforward_list< T > &rhs)
 
template<typename T >
bool operator<= (const etl::iforward_list< T > &lhs, const etl::iforward_list< T > &rhs)
 
template<typename T >
bool operator>= (const etl::iforward_list< T > &lhs, const etl::iforward_list< T > &rhs)
 
template<typename T >
reference_wrapper< T > ref (T &t)
 
template<typename T >
reference_wrapper< T > ref (reference_wrapper< T > t)
 
template<typename T >
reference_wrapper< const T > cref (const T &t)
 
template<typename T >
reference_wrapper< const T > cref (reference_wrapper< T > t)
 
template<typename F , typename T >
binder1st< F > bind1st (const F &f, const T &x)
 
template<typename F , typename T >
binder2nd< F > bind2nd (const F &f, const T &x)
 
template<typename T >
bool operator== (const etl::iindirect_vector< T > &lhs, const etl::iindirect_vector< T > &rhs)
 
template<typename T >
bool operator!= (const etl::iindirect_vector< T > &lhs, const etl::iindirect_vector< T > &rhs)
 
template<typename T >
bool operator< (const etl::iindirect_vector< T > &lhs, const etl::iindirect_vector< T > &rhs)
 
template<typename T >
bool operator> (const etl::iindirect_vector< T > &lhs, const etl::iindirect_vector< T > &rhs)
 
template<typename T >
bool operator<= (const etl::iindirect_vector< T > &lhs, const etl::iindirect_vector< T > &rhs)
 
template<typename T >
bool operator>= (const etl::iindirect_vector< T > &lhs, const etl::iindirect_vector< T > &rhs)
 
template<typename TLink >
etl::enable_if< etl::is_same< TLink, etl::forward_link< TLink::ID > >::value, void >::type link (TLink &lhs, TLink &rhs)
 
template<typename TLink >
etl::enable_if< etl::is_same< TLink, etl::forward_link< TLink::ID > >::value, void >::type link_splice (TLink &lhs, TLink &rhs)
 
template<typename TLink >
etl::enable_if< etl::is_same< TLink, etl::forward_link< TLink::ID > >::value, void >::type link (TLink *lhs, TLink *rhs)
 
template<typename TLink >
etl::enable_if< etl::is_same< TLink, etl::forward_link< TLink::ID > >::value, void >::type link_splice (TLink *lhs, TLink *rhs)
 
template<typename TLink >
etl::enable_if< etl::is_same< TLink, etl::forward_link< TLink::ID > >::value, void >::type link (TLink &lhs, TLink *rhs)
 
template<typename TLink >
etl::enable_if< etl::is_same< TLink, etl::forward_link< TLink::ID > >::value, void >::type link_splice (TLink &lhs, TLink *rhs)
 
template<typename TLink >
etl::enable_if< etl::is_same< TLink, etl::forward_link< TLink::ID > >::value, void >::type link (TLink *lhs, TLink &rhs)
 
template<typename TLink >
etl::enable_if< etl::is_same< TLink, etl::forward_link< TLink::ID > >::value, void >::type link_splice (TLink *lhs, TLink &rhs)
 
template<typename TLink >
etl::enable_if< etl::is_same< TLink, etl::forward_link< TLink::ID > >::value, void >::type link_splice (TLink &lhs, TLink &first, TLink &last)
 
template<typename TLink >
etl::enable_if< etl::is_same< TLink, etl::forward_link< TLink::ID > >::value, void >::type link_splice (TLink *lhs, TLink &first, TLink &last)
 
template<typename TLink >
etl::enable_if< etl::is_same< TLink, etl::forward_link< TLink::ID > >::value, void >::type unlink_after (TLink &node)
 
template<typename TLink >
etl::enable_if< etl::is_same< TLink, etl::forward_link< TLink::ID > >::value, void >::type unlink_after (TLink &before, TLink &last)
 
template<typename TLink >
etl::enable_if< etl::is_same< TLink, etl::bidirectional_link< TLink::ID > >::value, void >::type link (TLink &lhs, TLink &rhs)
 
template<typename TLink >
etl::enable_if< etl::is_same< TLink, etl::bidirectional_link< TLink::ID > >::value, void >::type link_splice (TLink &lhs, TLink &rhs)
 
template<typename TLink >
etl::enable_if< etl::is_same< TLink, etl::bidirectional_link< TLink::ID > >::value, void >::type link (TLink *lhs, TLink *rhs)
 
template<typename TLink >
etl::enable_if< etl::is_same< TLink, etl::bidirectional_link< TLink::ID > >::value, void >::type link_splice (TLink *lhs, TLink *rhs)
 
template<typename TLink >
etl::enable_if< etl::is_same< TLink, etl::bidirectional_link< TLink::ID > >::value, void >::type link (TLink &lhs, TLink *rhs)
 
template<typename TLink >
etl::enable_if< etl::is_same< TLink, etl::bidirectional_link< TLink::ID > >::value, void >::type link_splice (TLink &lhs, TLink *rhs)
 
template<typename TLink >
etl::enable_if< etl::is_same< TLink, etl::bidirectional_link< TLink::ID > >::value, void >::type link (TLink *lhs, TLink &rhs)
 
template<typename TLink >
etl::enable_if< etl::is_same< TLink, etl::bidirectional_link< TLink::ID > >::value, void >::type link_splice (TLink *lhs, TLink &rhs)
 
template<typename TLink >
etl::enable_if< etl::is_same< TLink, etl::bidirectional_link< TLink::ID > >::value, void >::type link_splice (TLink &lhs, TLink &first, TLink &last)
 
template<typename TLink >
etl::enable_if< etl::is_same< TLink, etl::bidirectional_link< TLink::ID > >::value, void >::type link_splice (TLink *lhs, TLink &first, TLink &last)
 
template<typename TLink >
etl::enable_if< etl::is_same< TLink, etl::bidirectional_link< TLink::ID > >::value, void >::type unlink (TLink &node)
 
template<typename TLink >
etl::enable_if< etl::is_same< TLink, etl::bidirectional_link< TLink::ID > >::value, void >::type unlink (TLink &first, TLink &last)
 
template<typename TLink >
etl::enable_if< etl::is_same< TLink, etl::tree_link< TLink::ID > >::value, void >::type link_left (TLink &parent, TLink &leaf)
 
template<typename TLink >
etl::enable_if< etl::is_same< TLink, etl::tree_link< TLink::ID > >::value, void >::type link_right (TLink &parent, TLink &leaf)
 
template<typename TLink >
etl::enable_if< etl::is_same< TLink, etl::tree_link< TLink::ID > >::value, void >::type link_left (TLink *parent, TLink *leaf)
 
template<typename TLink >
etl::enable_if< etl::is_same< TLink, etl::tree_link< TLink::ID > >::value, void >::type link_right (TLink *parent, TLink *leaf)
 
template<typename TLink >
etl::enable_if< etl::is_same< TLink, etl::tree_link< TLink::ID > >::value, void >::type link_left (TLink &parent, TLink *leaf)
 
template<typename TLink >
etl::enable_if< etl::is_same< TLink, etl::tree_link< TLink::ID > >::value, void >::type link_right (TLink &parent, TLink *leaf)
 
template<typename TLink >
etl::enable_if< etl::is_same< TLink, etl::tree_link< TLink::ID > >::value, void >::type link_left (TLink *parent, TLink &leaf)
 
template<typename TLink >
etl::enable_if< etl::is_same< TLink, etl::tree_link< TLink::ID > >::value, void >::type link_right (TLink *parent, TLink &leaf)
 
template<typename TLink >
etl::enable_if< etl::is_same< TLink, etl::tree_link< TLink::ID > >::value, void >::type link_rotate_left (TLink &parent, TLink &leaf)
 
template<typename TLink >
etl::enable_if< etl::is_same< TLink, etl::tree_link< TLink::ID > >::value, void >::type link_rotate_right (TLink &parent, TLink &leaf)
 
template<typename TLink >
etl::enable_if< etl::is_same< TLink, etl::tree_link< TLink::ID > >::value, void >::type link_rotate_left (TLink *parent, TLink *leaf)
 
template<typename TLink >
etl::enable_if< etl::is_same< TLink, etl::tree_link< TLink::ID > >::value, void >::type link_rotate_right (TLink *parent, TLink *leaf)
 
template<typename TLink >
etl::enable_if< etl::is_same< TLink, etl::tree_link< TLink::ID > >::value, void >::type link_rotate_left (TLink &parent, TLink *leaf)
 
template<typename TLink >
etl::enable_if< etl::is_same< TLink, etl::tree_link< TLink::ID > >::value, void >::type link_rotate_right (TLink &parent, TLink *leaf)
 
template<typename TLink >
etl::enable_if< etl::is_same< TLink, etl::tree_link< TLink::ID > >::value, void >::type link_rotate_left (TLink *parent, TLink &leaf)
 
template<typename TLink >
etl::enable_if< etl::is_same< TLink, etl::tree_link< TLink::ID > >::value, void >::type link_rotate_right (TLink *parent, TLink &leaf)
 
template<typename TLink >
etl::enable_if< etl::is_same< TLink, etl::tree_link< TLink::ID > >::value, void >::type link_rotate (TLink &parent, TLink &leaf)
 Automatically detects whether a left or right rotate is expected.
 
template<typename TLink >
etl::enable_if< etl::is_same< TLink, etl::tree_link< TLink::ID > >::value, void >::type link_rotate (TLink *parent, TLink *leaf)
 Automatically detects whether a left or right rotate is expected.
 
template<typename TLink >
etl::enable_if< etl::is_same< TLink, etl::tree_link< TLink::ID > >::value, void >::type link_rotate (TLink &parent, TLink *leaf)
 Automatically detects whether a left or right rotate is expected.
 
template<typename TLink >
etl::enable_if< etl::is_same< TLink, etl::tree_link< TLink::ID > >::value, void >::type link_rotate (TLink *parent, TLink &leaf)
 Automatically detects whether a left or right rotate is expected.
 
template<typename TIterator , typename TDistance >
ETL_CONSTEXPR17 void advance (TIterator &itr, TDistance n)
 
template<typename TIterator >
ETL_CONSTEXPR17 std::iterator_traits< TIterator >::difference_type distance (TIterator first, TIterator last)
 
template<typename TIterator >
ETL_CONSTEXPR17 TIterator prev (TIterator itr, typename etl::iterator_traits< TIterator >::difference_type n=1)
 
template<typename TIterator >
ETL_CONSTEXPR17 TIterator next (TIterator itr, typename etl::iterator_traits< TIterator >::difference_type n=1)
 
template<class TIterator >
ETL_CONSTEXPR17 bool operator== (const reverse_iterator< TIterator > &lhs, const reverse_iterator< TIterator > &rhs)
 
template<class TIterator >
ETL_CONSTEXPR17 bool operator!= (const reverse_iterator< TIterator > &lhs, const reverse_iterator< TIterator > &rhs)
 
template<class TIterator >
ETL_CONSTEXPR17 bool operator< (const reverse_iterator< TIterator > &lhs, const reverse_iterator< TIterator > &rhs)
 
template<class TIterator >
ETL_CONSTEXPR17 bool operator> (const reverse_iterator< TIterator > &lhs, const reverse_iterator< TIterator > &rhs)
 
template<class TIterator >
ETL_CONSTEXPR17 bool operator<= (const reverse_iterator< TIterator > &lhs, const reverse_iterator< TIterator > &rhs)
 
template<class TIterator >
ETL_CONSTEXPR17 bool operator>= (const reverse_iterator< TIterator > &lhs, const reverse_iterator< TIterator > &rhs)
 
template<class TIterator >
ETL_CONSTEXPR17 reverse_iterator< TIterator >::difference_type operator- (const reverse_iterator< TIterator > &lhs, const reverse_iterator< TIterator > &rhs)
 
template<class TIterator , class TDifference >
ETL_CONSTEXPR17 reverse_iterator< TIterator > operator+ (TDifference n, const reverse_iterator< TIterator > &itr)
 
template<typename T >
bool operator== (const etl::ilist< T > &lhs, const etl::ilist< T > &rhs)
 
template<typename T >
bool operator!= (const etl::ilist< T > &lhs, const etl::ilist< T > &rhs)
 
template<typename T >
bool operator< (const etl::ilist< T > &lhs, const etl::ilist< T > &rhs)
 
template<typename T >
bool operator> (const etl::ilist< T > &lhs, const etl::ilist< T > &rhs)
 
template<typename T >
bool operator<= (const etl::ilist< T > &lhs, const etl::ilist< T > &rhs)
 
template<typename T >
bool operator>= (const etl::ilist< T > &lhs, const etl::ilist< T > &rhs)
 
template<typename TKey , typename TMapped , typename TKeyCompare >
bool operator== (const etl::imap< TKey, TMapped, TKeyCompare > &lhs, const etl::imap< TKey, TMapped, TKeyCompare > &rhs)
 Template deduction guides. More...
 
template<typename TKey , typename TMapped , typename TKeyCompare >
bool operator!= (const etl::imap< TKey, TMapped, TKeyCompare > &lhs, const etl::imap< TKey, TMapped, TKeyCompare > &rhs)
 
template<typename TKey , typename TMapped , typename TKeyCompare >
bool operator< (const etl::imap< TKey, TMapped, TKeyCompare > &lhs, const etl::imap< TKey, TMapped, TKeyCompare > &rhs)
 
template<typename TKey , typename TMapped , typename TKeyCompare >
bool operator> (const etl::imap< TKey, TMapped, TKeyCompare > &lhs, const etl::imap< TKey, TMapped, TKeyCompare > &rhs)
 
template<typename TKey , typename TMapped , typename TKeyCompare >
bool operator<= (const etl::imap< TKey, TMapped, TKeyCompare > &lhs, const etl::imap< TKey, TMapped, TKeyCompare > &rhs)
 
template<typename TKey , typename TMapped , typename TKeyCompare >
bool operator>= (const etl::imap< TKey, TMapped, TKeyCompare > &lhs, const etl::imap< TKey, TMapped, TKeyCompare > &rhs)
 
template<typename T >
T * addressof (T &t)
 
template<typename TOutputIterator , typename T >
TOutputIterator uninitialized_fill (TOutputIterator o_begin, TOutputIterator o_end, const T &value)
 
template<typename TOutputIterator , typename T , typename TCounter >
TOutputIterator uninitialized_fill (TOutputIterator o_begin, TOutputIterator o_end, const T &value, TCounter &count)
 
template<typename TOutputIterator , typename TSize , typename T >
TOutputIterator uninitialized_fill_n (TOutputIterator o_begin, TSize n, const T &value)
 
template<typename TOutputIterator , typename TSize , typename T , typename TCounter >
TOutputIterator uninitialized_fill_n (TOutputIterator o_begin, TSize n, const T &value, TCounter &count)
 
template<typename TInputIterator , typename TOutputIterator >
TOutputIterator uninitialized_copy (TInputIterator i_begin, TInputIterator i_end, TOutputIterator o_begin)
 
template<typename TInputIterator , typename TOutputIterator , typename TCounter >
TOutputIterator uninitialized_copy (TInputIterator i_begin, TInputIterator i_end, TOutputIterator o_begin, TCounter &count)
 
template<typename TInputIterator , typename TSize , typename TOutputIterator >
TOutputIterator uninitialized_copy_n (TInputIterator i_begin, TSize n, TOutputIterator o_begin)
 
template<typename TInputIterator , typename TSize , typename TOutputIterator , typename TCounter >
TOutputIterator uninitialized_copy_n (TInputIterator i_begin, TSize n, TOutputIterator o_begin, TCounter &count)
 
template<typename TInputIterator , typename TOutputIterator >
TOutputIterator uninitialized_move (TInputIterator i_begin, TInputIterator i_end, TOutputIterator o_begin)
 
template<typename TInputIterator , typename TOutputIterator , typename TCounter >
TOutputIterator uninitialized_move (TInputIterator i_begin, TInputIterator i_end, TOutputIterator o_begin, TCounter &count)
 
template<typename TInputIterator , typename TSize , typename TOutputIterator >
TOutputIterator uninitialized_move_n (TInputIterator i_begin, TSize n, TOutputIterator o_begin)
 
template<typename TInputIterator , typename TSize , typename TOutputIterator , typename TCounter >
TOutputIterator uninitialized_move_n (TInputIterator i_begin, TSize n, TOutputIterator o_begin, TCounter &count)
 
template<typename TOutputIterator >
etl::enable_if< etl::is_trivially_constructible< typename etl::iterator_traits< TOutputIterator >::value_type >::value, void >::type uninitialized_default_construct (TOutputIterator, TOutputIterator)
 
template<typename TOutputIterator >
etl::enable_if<!etl::is_trivially_constructible< typename etl::iterator_traits< TOutputIterator >::value_type >::value, void >::type uninitialized_default_construct (TOutputIterator o_begin, TOutputIterator o_end)
 
template<typename TOutputIterator , typename TCounter >
etl::enable_if< etl::is_trivially_constructible< typename etl::iterator_traits< TOutputIterator >::value_type >::value, void >::type uninitialized_default_construct (TOutputIterator o_begin, TOutputIterator o_end, TCounter &count)
 
template<typename TOutputIterator , typename TCounter >
etl::enable_if<!etl::is_trivially_constructible< typename etl::iterator_traits< TOutputIterator >::value_type >::value, void >::type uninitialized_default_construct (TOutputIterator o_begin, TOutputIterator o_end, TCounter &count)
 
template<typename TOutputIterator , typename TSize >
etl::enable_if< etl::is_trivially_constructible< typename etl::iterator_traits< TOutputIterator >::value_type >::value, TOutputIterator >::type uninitialized_default_construct_n (TOutputIterator o_begin, TSize n)
 
template<typename TOutputIterator , typename TSize >
etl::enable_if<!etl::is_trivially_constructible< typename etl::iterator_traits< TOutputIterator >::value_type >::value, TOutputIterator >::type uninitialized_default_construct_n (TOutputIterator o_begin, TSize n)
 
template<typename TOutputIterator , typename TSize , typename TCounter >
etl::enable_if< etl::is_trivially_constructible< typename etl::iterator_traits< TOutputIterator >::value_type >::value, TOutputIterator >::type uninitialized_default_construct_n (TOutputIterator o_begin, TSize n, TCounter &count)
 
template<typename TOutputIterator , typename TSize , typename TCounter >
etl::enable_if<!etl::is_trivially_constructible< typename etl::iterator_traits< TOutputIterator >::value_type >::value, TOutputIterator >::type uninitialized_default_construct_n (TOutputIterator o_begin, TSize n, TCounter &count)
 
template<typename TOutputIterator >
etl::enable_if< etl::is_trivially_constructible< typename etl::iterator_traits< TOutputIterator >::value_type >::value, void >::type uninitialized_value_construct (TOutputIterator o_begin, TOutputIterator o_end)
 
template<typename TOutputIterator >
etl::enable_if<!etl::is_trivially_constructible< typename etl::iterator_traits< TOutputIterator >::value_type >::value, void >::type uninitialized_value_construct (TOutputIterator o_begin, TOutputIterator o_end)
 
template<typename TOutputIterator , typename TCounter >
void uninitialized_value_construct (TOutputIterator o_begin, TOutputIterator o_end, TCounter &count)
 
template<typename TOutputIterator , typename TSize >
TOutputIterator uninitialized_value_construct_n (TOutputIterator o_begin, TSize n)
 
template<typename TOutputIterator , typename TSize , typename TCounter >
TOutputIterator uninitialized_value_construct_n (TOutputIterator o_begin, TSize n, TCounter &count)
 
template<typename T >
etl::enable_if< etl::is_trivially_destructible< T >::value, void >::type destroy_at (T *)
 
template<typename T >
etl::enable_if<!etl::is_trivially_destructible< T >::value, void >::type destroy_at (T *p)
 
template<typename T , typename TCounter >
etl::enable_if< etl::is_trivially_destructible< T >::value, void >::type destroy_at (T *, TCounter &count)
 
template<typename T , typename TCounter >
etl::enable_if<!etl::is_trivially_destructible< T >::value, void >::type destroy_at (T *p, TCounter &count)
 
template<typename TIterator >
etl::enable_if< etl::is_trivially_destructible< typename etl::iterator_traits< TIterator >::value_type >::value, void >::type destroy (TIterator, TIterator)
 
template<typename TIterator >
etl::enable_if<!etl::is_trivially_destructible< typename etl::iterator_traits< TIterator >::value_type >::value, void >::type destroy (TIterator i_begin, TIterator i_end)
 
template<typename TIterator , typename TCounter >
etl::enable_if< etl::is_trivially_destructible< typename etl::iterator_traits< TIterator >::value_type >::value, void >::type destroy (TIterator i_begin, TIterator i_end, TCounter &count)
 
template<typename TIterator , typename TCounter >
etl::enable_if<!etl::is_trivially_destructible< typename etl::iterator_traits< TIterator >::value_type >::value, void >::type destroy (TIterator i_begin, TIterator i_end, TCounter &count)
 
template<typename TIterator , typename TSize >
etl::enable_if< etl::is_trivially_destructible< typename etl::iterator_traits< TIterator >::value_type >::value, TIterator >::type destroy_n (TIterator i_begin, TSize n)
 
template<typename TIterator , typename TSize >
etl::enable_if<!etl::is_trivially_destructible< typename etl::iterator_traits< TIterator >::value_type >::value, TIterator >::type destroy_n (TIterator i_begin, TSize n)
 
template<typename TIterator , typename TSize , typename TCounter >
etl::enable_if< etl::is_trivially_destructible< typename etl::iterator_traits< TIterator >::value_type >::value, TIterator >::type destroy_n (TIterator i_begin, TSize n, TCounter &count)
 
template<typename TIterator , typename TSize , typename TCounter >
etl::enable_if<!etl::is_trivially_destructible< typename etl::iterator_traits< TIterator >::value_type >::value, TIterator >::type destroy_n (TIterator i_begin, TSize n, TCounter &count)
 
template<typename T >
etl::enable_if< etl::is_trivially_constructible< T >::value, void >::type create_default_at (T *)
 
template<typename T , typename TCounter >
etl::enable_if< etl::is_trivially_constructible< T >::value, void >::type create_default_at (T *, TCounter &count)
 
template<typename T >
etl::enable_if<!etl::is_trivially_constructible< T >::value, void >::type create_default_at (T *p)
 
template<typename T , typename TCounter >
etl::enable_if<!etl::is_trivially_constructible< T >::value, void >::type create_default_at (T *p, TCounter &count)
 
template<typename T >
void create_value_at (T *p)
 
template<typename T , typename TCounter >
void create_value_at (T *p, TCounter &count)
 
template<typename T >
void create_copy_at (T *p, const T &value)
 
template<typename T , typename TCounter >
void create_copy_at (T *p, const T &value, TCounter &count)
 
template<typename T >
T & make_default_at (T *p)
 
template<typename T , typename TCounter >
T & make_default_at (T *p, TCounter &count)
 
template<typename T >
T & make_copy_at (T *p, const T &other)
 
template<typename T , typename TCounter >
T & make_copy_at (T *p, const T &other, TCounter &count)
 
template<typename T , typename TParameter >
T & make_value_at (T *p, const TParameter &value)
 
template<typename T , typename TParameter , typename TCounter >
T & make_value_at (T *p, const TParameter &value, TCounter &count)
 
void memory_clear (volatile char *p, size_t n)
 
template<typename T >
void memory_clear (volatile T &object)
 
template<typename T >
void memory_clear_range (volatile T *begin, size_t n)
 
template<typename T >
void memory_clear_range (volatile T *begin, volatile T *end)
 
void memory_set (volatile char *p, size_t n, char value)
 
template<typename T >
void memory_set (volatile T &object, const char value)
 
template<typename T >
void memory_set_range (volatile T *begin, size_t n, const char value)
 
template<typename T >
void memory_set_range (volatile T *begin, volatile T *end, const char value)
 
template<typename TKey , typename TMapped , typename TKeyCompare >
bool operator== (const etl::imultimap< TKey, TMapped, TKeyCompare > &lhs, const etl::imultimap< TKey, TMapped, TKeyCompare > &rhs)
 Template deduction guides. More...
 
template<typename TKey , typename TMapped , typename TKeyCompare >
bool operator!= (const etl::imultimap< TKey, TMapped, TKeyCompare > &lhs, const etl::imultimap< TKey, TMapped, TKeyCompare > &rhs)
 
template<typename TKey , typename TMapped , typename TKeyCompare >
bool operator< (const etl::imultimap< TKey, TMapped, TKeyCompare > &lhs, const etl::imultimap< TKey, TMapped, TKeyCompare > &rhs)
 
template<typename TKey , typename TMapped , typename TKeyCompare >
bool operator> (const etl::imultimap< TKey, TMapped, TKeyCompare > &lhs, const etl::imultimap< TKey, TMapped, TKeyCompare > &rhs)
 
template<typename TKey , typename TMapped , typename TKeyCompare >
bool operator<= (const etl::imultimap< TKey, TMapped, TKeyCompare > &lhs, const etl::imultimap< TKey, TMapped, TKeyCompare > &rhs)
 
template<typename TKey , typename TMapped , typename TKeyCompare >
bool operator>= (const etl::imultimap< TKey, TMapped, TKeyCompare > &lhs, const etl::imultimap< TKey, TMapped, TKeyCompare > &rhs)
 
template<typename TKey , typename TCompare >
bool operator== (const etl::imultiset< TKey, TCompare > &lhs, const etl::imultiset< TKey, TCompare > &rhs)
 Template deduction guides. More...
 
template<typename TKey , typename TCompare >
bool operator!= (const etl::imultiset< TKey, TCompare > &lhs, const etl::imultiset< TKey, TCompare > &rhs)
 
template<typename TKey , typename TCompare >
bool operator< (const etl::imultiset< TKey, TCompare > &lhs, const etl::imultiset< TKey, TCompare > &rhs)
 
template<typename TKey , typename TCompare >
bool operator> (const etl::imultiset< TKey, TCompare > &lhs, const etl::imultiset< TKey, TCompare > &rhs)
 
template<typename TKey , typename TCompare >
bool operator<= (const etl::imultiset< TKey, TCompare > &lhs, const etl::imultiset< TKey, TCompare > &rhs)
 
template<typename TKey , typename TCompare >
bool operator>= (const etl::imultiset< TKey, TCompare > &lhs, const etl::imultiset< TKey, TCompare > &rhs)
 
template<typename T >
ETL_CONSTEXPR etl::enable_if< etl::is_signed< T >::value, bool >::type is_negative (const T value)
 
template<typename T >
ETL_CONSTEXPR etl::enable_if< etl::is_unsigned< T >::value, bool >::type is_negative (const T)
 
template<typename TIterator , typename T >
void iota (TIterator first, TIterator last, T value)
 
template<typename T >
bool operator== (const etl::optional< T > &lhs, const etl::optional< T > &rhs)
 Equality operator. cppreference 1.
 
template<typename T >
bool operator!= (const etl::optional< T > &lhs, const etl::optional< T > &rhs)
 Equality operator. cppreference 2.
 
template<typename T >
bool operator< (const etl::optional< T > &lhs, const etl::optional< T > &rhs)
 Less than operator. cppreference 3.
 
template<typename T >
bool operator<= (const etl::optional< T > &lhs, const etl::optional< T > &rhs)
 Less than equal operator. cppreference 4.
 
template<typename T >
bool operator> (const etl::optional< T > &lhs, const etl::optional< T > &rhs)
 greater than operator. cppreference 5
 
template<typename T >
bool operator>= (const etl::optional< T > &lhs, const etl::optional< T > &rhs)
 greater than equal operator. cppreference 6
 
template<typename T >
bool operator== (const etl::optional< T > &lhs, etl::nullopt_t)
 Equality operator. cppreference 7.
 
template<typename T >
bool operator== (etl::nullopt_t, const etl::optional< T > &rhs)
 Equality operator. cppreference 8.
 
template<typename T >
bool operator!= (const etl::optional< T > &lhs, etl::nullopt_t)
 Inequality operator. cppreference 9.
 
template<typename T >
bool operator!= (etl::nullopt_t, const etl::optional< T > &rhs)
 Inequality operator. cppreference 10.
 
template<typename T >
bool operator< (const etl::optional< T > &, etl::nullopt_t)
 Less than operator. cppreference 11.
 
template<typename T >
bool operator< (etl::nullopt_t, const etl::optional< T > &rhs)
 Less than operator. cppreference 12.
 
template<typename T >
bool operator<= (const etl::optional< T > &lhs, etl::nullopt_t)
 Less than equal operator. cppreference 13.
 
template<typename T >
bool operator<= (etl::nullopt_t, const etl::optional< T > &)
 Less than equal operator. cppreference 14.
 
template<typename T >
bool operator> (const etl::optional< T > &lhs, etl::nullopt_t)
 Greater than operator. cppreference 15.
 
template<typename T >
bool operator> (etl::nullopt_t, const etl::optional< T > &)
 Greater than operator. cppreference 16.
 
template<typename T >
bool operator>= (const etl::optional< T > &, etl::nullopt_t)
 Greater than equal operator. cppreference 17.
 
template<typename T >
bool operator>= (etl::nullopt_t, const etl::optional< T > &rhs)
 Greater than equal operator. cppreference 18.
 
template<typename T , typename U >
bool operator== (const etl::optional< T > &lhs, const U &rhs)
 Equality operator. cppreference 19.
 
template<typename T , typename U >
bool operator!= (const etl::optional< T > &lhs, const U &rhs)
 Inequality operator. cppreference 21.
 
template<typename T , typename U >
bool operator== (const U &lhs, const etl::optional< T > &rhs)
 Equality operator. cppreference 20.
 
template<typename T , typename U >
bool operator!= (const U &lhs, const etl::optional< T > &rhs)
 Inequality operator. cppreference 22.
 
template<typename T , typename U >
bool operator< (const etl::optional< T > &lhs, const U &rhs)
 Less than operator. cppreference 23.
 
template<typename T , typename U >
bool operator< (const U &lhs, const etl::optional< T > &rhs)
 Less than operator. cppreference 24.
 
template<typename T , typename U >
bool operator<= (const etl::optional< T > &lhs, const U &rhs)
 Less than equal operator. cppreference 25.
 
template<typename T , typename U >
bool operator<= (const U &lhs, const etl::optional< T > &rhs)
 Less than equal operator. cppreference 26.
 
template<typename T , typename U >
bool operator> (const etl::optional< T > &lhs, const U &rhs)
 Greater than operator. cppreference 27.
 
template<typename T , typename U >
bool operator> (const U &lhs, const etl::optional< T > &rhs)
 Greater than operator. cppreference 28.
 
template<typename T , typename U >
bool operator>= (const etl::optional< T > &lhs, const U &rhs)
 Greater than equal operator. cppreference 29.
 
template<typename T , typename U >
bool operator>= (const U &lhs, const etl::optional< T > &rhs)
 Greater than equal operator. cppreference 30.
 
template<typename T >
etl::optional< typename etl::decay< T >::type > make_optional (T &value)
 Make an optional.
 
template<typename T >
bool operator== (const etl::ivector< T * > &lhs, const etl::ivector< T * > &rhs)
 
template<typename T >
bool operator!= (const etl::ivector< T * > &lhs, const etl::ivector< T * > &rhs)
 
template<typename T >
bool operator< (const etl::ivector< T * > &lhs, const etl::ivector< T * > &rhs)
 
template<typename T >
bool operator> (const etl::ivector< T * > &lhs, const etl::ivector< T * > &rhs)
 
template<typename T >
bool operator<= (const etl::ivector< T * > &lhs, const etl::ivector< T * > &rhs)
 
template<typename T >
bool operator>= (const etl::ivector< T * > &lhs, const etl::ivector< T * > &rhs)
 
bool pvoidvector_equal (const etl::pvoidvector &lhs, const etl::pvoidvector &rhs)
 
bool pvoidvector_not_equal (const etl::pvoidvector &lhs, const etl::pvoidvector &rhs)
 
bool pvoidvector_less_than (const etl::pvoidvector &lhs, const etl::pvoidvector &rhs)
 
bool pvoidvector_greater_than (const etl::pvoidvector &lhs, const etl::pvoidvector &rhs)
 
bool pvoidvector_less_than_equal (const etl::pvoidvector &lhs, const etl::pvoidvector &rhs)
 
bool pvoidvector_greater_than_equal (const etl::pvoidvector &lhs, const etl::pvoidvector &rhs)
 
bool operator== (const etl::pvoidvector &lhs, const etl::pvoidvector &rhs)
 
bool operator!= (const etl::pvoidvector &lhs, const etl::pvoidvector &rhs)
 
bool operator< (const etl::pvoidvector &lhs, const etl::pvoidvector &rhs)
 
bool operator> (const etl::pvoidvector &lhs, const etl::pvoidvector &rhs)
 
bool operator<= (const etl::pvoidvector &lhs, const etl::pvoidvector &rhs)
 
bool operator>= (const etl::pvoidvector &lhs, const etl::pvoidvector &rhs)
 
template<typename TKey , typename TMapped , typename TKeyCompare >
bool operator== (const etl::ireference_flat_map< TKey, TMapped, TKeyCompare > &lhs, const etl::ireference_flat_map< TKey, TMapped, TKeyCompare > &rhs)
 
template<typename TKey , typename TMapped , typename TKeyCompare >
bool operator!= (const etl::ireference_flat_map< TKey, TMapped, TKeyCompare > &lhs, const etl::ireference_flat_map< TKey, TMapped, TKeyCompare > &rhs)
 
template<typename TKey , typename TMapped , typename TKeyCompare >
bool operator== (const etl::ireference_flat_multimap< TKey, TMapped, TKeyCompare > &lhs, const etl::ireference_flat_multimap< TKey, TMapped, TKeyCompare > &rhs)
 
template<typename TKey , typename TMapped , typename TKeyCompare >
bool operator!= (const etl::ireference_flat_multimap< TKey, TMapped, TKeyCompare > &lhs, const etl::ireference_flat_multimap< TKey, TMapped, TKeyCompare > &rhs)
 
template<typename T , typename TKeyCompare >
bool operator== (const etl::ireference_flat_multiset< T, TKeyCompare > &lhs, const etl::ireference_flat_multiset< T, TKeyCompare > &rhs)
 
template<typename T , typename TKeyCompare >
bool operator!= (const etl::ireference_flat_multiset< T, TKeyCompare > &lhs, const etl::ireference_flat_multiset< T, TKeyCompare > &rhs)
 
template<typename T , typename TKeyCompare >
bool operator== (const etl::ireference_flat_set< T, TKeyCompare > &lhs, const etl::ireference_flat_set< T, TKeyCompare > &rhs)
 
template<typename T , typename TKeyCompare >
bool operator!= (const etl::ireference_flat_set< T, TKeyCompare > &lhs, const etl::ireference_flat_set< T, TKeyCompare > &rhs)
 
template<const size_t SCALING, typename T >
round_ceiling_unscaled (T value)
 
template<const size_t SCALING, typename T >
round_ceiling_scaled (T value)
 
template<const size_t SCALING, typename T >
round_floor_unscaled (T value)
 
template<const size_t SCALING, typename T >
round_floor_scaled (T value)
 
template<const size_t SCALING, typename T >
round_half_up_unscaled (T value)
 
template<const size_t SCALING, typename T >
round_half_up_scaled (T value)
 
template<const size_t SCALING, typename T >
round_half_down_unscaled (T value)
 
template<const size_t SCALING, typename T >
round_half_down_scaled (T value)
 
template<const size_t SCALING, typename T >
round_zero_unscaled (T value)
 
template<const size_t SCALING, typename T >
round_zero_scaled (T value)
 
template<const size_t SCALING, typename T >
round_infinity_unscaled (T value)
 
template<const size_t SCALING, typename T >
round_infinity_scaled (T value)
 
template<const size_t SCALING, typename T >
round_half_even_unscaled (T value)
 
template<const size_t SCALING, typename T >
round_half_even_scaled (T value)
 
template<const size_t SCALING, typename T >
round_half_odd_unscaled (T value)
 
template<const size_t SCALING, typename T >
round_half_odd_scaled (T value)
 
 ETL_DEPRECATED_REASON ("Misspelt class name") typedef scheduler_policy_sequential_single scheduler_policy_sequencial_single
 Typedef for backwards compatibility with miss-spelt struct name.
 
template<typename TKey , typename TCompare >
bool operator== (const etl::iset< TKey, TCompare > &lhs, const etl::iset< TKey, TCompare > &rhs)
 Template deduction guides. More...
 
template<typename TKey , typename TCompare >
bool operator!= (const etl::iset< TKey, TCompare > &lhs, const etl::iset< TKey, TCompare > &rhs)
 
template<typename TKey , typename TCompare >
bool operator< (const etl::iset< TKey, TCompare > &lhs, const etl::iset< TKey, TCompare > &rhs)
 
template<typename TKey , typename TCompare >
bool operator> (const etl::iset< TKey, TCompare > &lhs, const etl::iset< TKey, TCompare > &rhs)
 
template<typename TKey , typename TCompare >
bool operator<= (const etl::iset< TKey, TCompare > &lhs, const etl::iset< TKey, TCompare > &rhs)
 
template<typename TKey , typename TCompare >
bool operator>= (const etl::iset< TKey, TCompare > &lhs, const etl::iset< TKey, TCompare > &rhs)
 
template<size_t ARRAY_SIZE>
etl::string< ARRAY_SIZE - 1 > make_string (const char(&text)[ARRAY_SIZE])
 Hash function. More...
 
template<const size_t MAX_SIZE, const size_t SIZE>
etl::string< MAX_SIZE > make_string_with_capacity (const char(&text)[SIZE])
 Make string with max capacity from string literal or array.
 
template<typename TIString >
void trim_from_left (TIString &s, typename TIString::const_pointer trim_characters)
 
template<typename TIString >
void trim_whitespace_left (TIString &s)
 
template<typename TStringView >
TStringView trim_from_view_left (const TStringView &view, typename TStringView::const_pointer trim_characters)
 
template<typename TStringView >
TStringView trim_view_whitespace_left (TStringView &s)
 
template<typename TIString >
void trim_left (TIString &s, typename TIString::const_pointer delimiters)
 
template<typename TStringView >
TStringView trim_view_left (const TStringView &view, typename TStringView::const_pointer delimiters)
 
template<typename TIString >
void trim_from_right (TIString &s, typename TIString::const_pointer trim_characters)
 
template<typename TIString >
void trim_whitespace_right (TIString &s)
 
template<typename TStringView >
TStringView trim_from_view_right (const TStringView &view, typename TStringView::const_pointer trim_characters)
 
template<typename TStringView >
TStringView trim_view_whitespace_right (TStringView &view)
 
template<typename TIString >
void trim_right (TIString &s, typename TIString::const_pointer delimiters)
 trim_right
 
template<typename TStringView >
TStringView trim_view_right (const TStringView &view, typename TStringView::const_pointer delimiters)
 trim_view_right
 
template<typename TIString >
void trim_from (TIString &s, typename TIString::const_pointer trim_characters)
 
template<typename TIString >
void trim_whitespace (TIString &s)
 
template<typename TStringView >
TStringView trim_from_view (const TStringView &view, typename TStringView::const_pointer trim_characters)
 
template<typename TStringView >
TStringView trim_view_whitespace (const TStringView &view)
 
template<typename TIString >
void trim (TIString &s, typename TIString::const_pointer delimiters)
 
template<typename TStringView >
TStringView trim_view (const TStringView &view, typename TStringView::const_pointer delimiters)
 
template<typename TIString >
void left_n (TIString &s, typename TIString::size_type n)
 Get up to the first n characters.
 
template<typename TStringView >
TStringView left_n_view (const TStringView &view, typename TStringView::size_type n)
 Get a view of up to the first n characters.
 
template<typename TIString >
void right_n (TIString &s, typename TIString::size_type n)
 Get up to the last n characters.
 
template<typename TStringView >
TStringView right_n_view (const TStringView &view, typename TStringView::size_type n)
 Get a view of up to the last n characters.
 
template<typename TIString >
void reverse (TIString &s)
 
template<typename TIString , typename TPair >
void replace_characters (TIString &s, const TPair *pairsbegin, const TPair *pairsend)
 replace_characters
 
template<typename TIString , typename TPair >
void replace_strings (TIString &s, const TPair *pairsbegin, const TPair *pairsend)
 replace_strings
 
template<typename TIterator , typename TPointer >
TIterator find_first_of (TIterator first, TIterator last, TPointer delimiters)
 Find first of any of delimiters within the string.
 
template<typename TIString , typename TPointer >
TIString::iterator find_first_of (TIString &s, TPointer delimiters)
 Find first of any of delimiters within the string.
 
template<typename TIString , typename TPointer >
TIString::const_iterator find_first_of (const TIString &s, TPointer delimiters)
 Find first of any of delimiters within the string.
 
template<typename TIterator , typename TPointer >
TIterator find_first_not_of (TIterator first, TIterator last, TPointer delimiters)
 Find first not of any of delimiters within the string.
 
template<typename TIString , typename TPointer >
TIString::iterator find_first_not_of (TIString &s, TPointer delimiters)
 Find first not of any of delimiters within the string.
 
template<typename TIString , typename TPointer >
TIString::const_iterator find_first_not_of (const TIString &s, TPointer delimiters)
 Find first not of any of delimiters within the string.
 
template<typename TIterator , typename TPointer >
TIterator find_last_of (TIterator first, TIterator last, TPointer delimiters)
 Find last of any of delimiters within the string.
 
template<typename TIString , typename TPointer >
TIString::iterator find_last_of (TIString &s, TPointer delimiters)
 Find last of any of delimiters within the string.
 
template<typename TIString , typename TPointer >
TIString::const_iterator find_last_of (const TIString &s, TPointer delimiters)
 Find last of any of delimiters within the string.
 
template<typename TIterator , typename TPointer >
TIterator find_last_not_of (TIterator first, TIterator last, TPointer delimiters)
 Find last not of any of delimiters within the string.
 
template<typename TIString , typename TPointer >
TIString::iterator find_last_not_of (TIString &s, TPointer delimiters)
 Find last not of any of delimiters within the string.
 
template<typename TIString , typename TPointer >
TIString::const_iterator find_last_not_of (const TIString &s, TPointer delimiters)
 Find last not of any of delimiters within the string.
 
template<typename TInput , typename TStringView >
etl::optional< TStringView > get_token (const TInput &input, typename TInput::const_pointer delimiters, const etl::optional< TStringView > &last_view, bool ignore_empty_tokens)
 get_token
 
template<typename TIString >
void pad_left (TIString &s, typename TIString::size_type required_size, typename TIString::value_type pad_char)
 pad_left
 
template<typename TIString >
void pad_right (TIString &s, typename TIString::size_type required_size, typename TIString::value_type pad_char)
 pad_right
 
template<typename TIString >
void pad (TIString &s, typename TIString::size_type required_size, string_pad_direction pad_direction, typename TIString::value_type pad_char)
 pad
 
template<typename TString >
void to_upper_case (TString &s)
 to_upper_case
 
template<typename TString >
void to_lower_case (TString &s)
 to_lower_case
 
template<typename TString >
void to_sentence_case (TString &s)
 to_sentence_case
 
template<size_t ARRAY_SIZE>
string_view make_string_view (const char(&text)[ARRAY_SIZE])
 make_string_view.
 
template<size_t ARRAY_SIZE>
wstring_view make_string_view (const wchar_t(&text)[ARRAY_SIZE])
 
template<size_t ARRAY_SIZE>
u16string_view make_string_view (const char16_t(&text)[ARRAY_SIZE])
 
template<size_t ARRAY_SIZE>
u32string_view make_string_view (const char32_t(&text)[ARRAY_SIZE])
 
template<typename T >
etl::enable_if<!etl::is_same< T, etl::istring >::value &&!etl::is_same< T, etl::string_view >::value, const etl::istring & >::type to_string (const T value, etl::istring &str, bool append=false)
 
template<typename T >
etl::enable_if<!etl::is_same< T, etl::istring >::value &&!etl::is_same< T, etl::string_view >::value, const etl::istring & >::type to_string (const T value, etl::istring &str, const etl::format_spec &format, bool append=false)
 
template<typename T >
etl::enable_if< etl::is_same< T, etl::istring >::value, const etl::istring & >::type to_string (const T &value, etl::istring &str, bool append=false)
 
template<typename T >
etl::enable_if< etl::is_same< T, etl::istring >::value, const etl::istring & >::type to_string (const etl::istring &value, T &str, const etl::format_spec &format, bool append=false)
 
template<typename T >
etl::enable_if< etl::is_same< T, etl::string_view >::value, const etl::istring & >::type to_string (T value, etl::istring &str, bool append=false)
 
template<typename T >
etl::enable_if< etl::is_same< T, etl::string_view >::value, const etl::istring & >::type to_string (T value, etl::istring &str, const etl::format_spec &format, bool append=false)
 
template<typename T >
etl::enable_if<!etl::is_same< T, etl::iu16string >::value &&!etl::is_same< T, etl::u16string_view >::value, const etl::iu16string & >::type to_string (const T value, etl::iu16string &str, bool append=false)
 
template<typename T >
etl::enable_if<!etl::is_same< T, etl::iu16string >::value &&!etl::is_same< T, etl::u16string_view >::value, const etl::iu16string & >::type to_string (const T value, etl::iu16string &str, const etl::u16format_spec &format, bool append=false)
 
template<typename T >
etl::enable_if< etl::is_same< T, etl::iu16string >::value, const etl::iu16string & >::type to_string (const T &value, etl::iu16string &str, bool append=false)
 
template<typename T >
etl::enable_if< etl::is_same< T, etl::iu16string >::value, const etl::iu16string & >::type to_string (const etl::iu16string &value, T &str, const etl::u16format_spec &format, bool append=false)
 
template<typename T >
etl::enable_if< etl::is_same< T, etl::u16string_view >::value, const etl::iu16string & >::type to_string (T value, etl::iu16string &str, bool append=false)
 
template<typename T >
etl::enable_if< etl::is_same< T, etl::u16string_view >::value, const etl::iu16string & >::type to_string (T value, etl::iu16string &str, const etl::u16format_spec &format, bool append=false)
 
template<typename T >
etl::enable_if<!etl::is_same< T, etl::iu32string >::value &&!etl::is_same< T, etl::u32string_view >::value, const etl::iu32string & >::type to_string (const T value, etl::iu32string &str, bool append=false)
 
template<typename T >
etl::enable_if<!etl::is_same< T, etl::iu32string >::value &&!etl::is_same< T, etl::u32string_view >::value, const etl::iu32string & >::type to_string (const T value, etl::iu32string &str, const etl::u32format_spec &format, bool append=false)
 
template<typename T >
etl::enable_if< etl::is_same< T, etl::iu32string >::value, const etl::iu32string & >::type to_string (const T &value, etl::iu32string &str, bool append=false)
 
template<typename T >
etl::enable_if< etl::is_same< T, etl::iu32string >::value, const etl::iu32string & >::type to_string (const etl::iu32string &value, T &str, const etl::u32format_spec &format, bool append=false)
 
template<typename T >
etl::enable_if< etl::is_same< T, etl::u32string_view >::value, const etl::iu32string & >::type to_string (T value, etl::iu32string &str, bool append=false)
 
template<typename T >
etl::enable_if< etl::is_same< T, etl::u32string_view >::value, const etl::iu32string & >::type to_string (T value, etl::iu32string &str, const etl::u32format_spec &format, bool append=false)
 
template<typename T >
etl::enable_if<!etl::is_same< T, etl::iwstring >::value &&!etl::is_same< T, etl::wstring_view >::value, const etl::iwstring & >::type to_string (const T value, etl::iwstring &str, bool append=false)
 
template<typename T >
etl::enable_if<!etl::is_same< T, etl::iwstring >::value &&!etl::is_same< T, etl::wstring_view >::value, const etl::iwstring & >::type to_string (const T value, etl::iwstring &str, const etl::wformat_spec &format, bool append=false)
 
template<typename T >
etl::enable_if< etl::is_same< T, etl::iwstring >::value, const etl::iwstring & >::type to_string (const T &value, etl::iwstring &str, bool append=false)
 
template<typename T >
etl::enable_if< etl::is_same< T, etl::iwstring >::value, const etl::iwstring & >::type to_string (const etl::iwstring &value, T &str, const etl::wformat_spec &format, bool append=false)
 
template<typename T >
etl::enable_if< etl::is_same< T, etl::wstring_view >::value, const etl::iwstring & >::type to_string (T value, etl::iwstring &str, bool append=false)
 
template<typename T >
etl::enable_if< etl::is_same< T, etl::wstring_view >::value, const etl::iwstring & >::type to_string (T value, etl::iwstring &str, const etl::wformat_spec &format, bool append=false)
 
template<size_t ARRAY_SIZE>
etl::u16string< ARRAY_SIZE==1 ? 1 :ARRAY_SIZE - 1 > make_string (const char16_t(&text)[ARRAY_SIZE])
 Hash function. More...
 
template<const size_t MAX_SIZE, const size_t SIZE>
etl::u16string< MAX_SIZE > make_string_with_capacity (const char16_t(&text)[SIZE])
 Make string with max capacity from string literal or array.
 
template<size_t ARRAY_SIZE>
etl::u32string< ARRAY_SIZE==1 ? 1 :ARRAY_SIZE - 1 > make_string (const char32_t(&text)[ARRAY_SIZE])
 Hash function. More...
 
template<const size_t MAX_SIZE, const size_t SIZE>
etl::u32string< MAX_SIZE > make_string_with_capacity (const char32_t(&text)[SIZE])
 Make string with max capacity from string literal or array.
 
template<typename TKey , typename TMapped , typename TKeyCompare >
bool operator== (const etl::iunordered_map< TKey, TMapped, TKeyCompare > &lhs, const etl::iunordered_map< TKey, TMapped, TKeyCompare > &rhs)
 
template<typename TKey , typename TMapped , typename TKeyCompare >
bool operator!= (const etl::iunordered_map< TKey, TMapped, TKeyCompare > &lhs, const etl::iunordered_map< TKey, TMapped, TKeyCompare > &rhs)
 
template<typename TKey , typename TMapped , typename TKeyCompare >
bool operator== (const etl::iunordered_multimap< TKey, TMapped, TKeyCompare > &lhs, const etl::iunordered_multimap< TKey, TMapped, TKeyCompare > &rhs)
 
template<typename TKey , typename TMapped , typename TKeyCompare >
bool operator!= (const etl::iunordered_multimap< TKey, TMapped, TKeyCompare > &lhs, const etl::iunordered_multimap< TKey, TMapped, TKeyCompare > &rhs)
 
template<typename TKey , typename TMapped , typename TKeyCompare >
bool operator== (const etl::iunordered_multiset< TKey, TMapped, TKeyCompare > &lhs, const etl::iunordered_multiset< TKey, TMapped, TKeyCompare > &rhs)
 
template<typename TKey , typename TMapped , typename TKeyCompare >
bool operator!= (const etl::iunordered_multiset< TKey, TMapped, TKeyCompare > &lhs, const etl::iunordered_multiset< TKey, TMapped, TKeyCompare > &rhs)
 
template<typename TKey , typename TMapped , typename TKeyCompare >
bool operator== (const etl::iunordered_set< TKey, TMapped, TKeyCompare > &lhs, const etl::iunordered_set< TKey, TMapped, TKeyCompare > &rhs)
 
template<typename TKey , typename TMapped , typename TKeyCompare >
bool operator!= (const etl::iunordered_set< TKey, TMapped, TKeyCompare > &lhs, const etl::iunordered_set< TKey, TMapped, TKeyCompare > &rhs)
 
template<typename T1 , typename T2 >
pair< T1, T2 > make_pair (T1 a, T2 b)
 
template<typename T1 , typename T2 >
void swap (pair< T1, T2 > &a, pair< T1, T2 > &b)
 
template<typename T1 , typename T2 >
bool operator== (const pair< T1, T2 > &a, const pair< T1, T2 > &b)
 
template<typename T1 , typename T2 >
bool operator!= (const pair< T1, T2 > &a, const pair< T1, T2 > &b)
 
template<typename T1 , typename T2 >
bool operator< (const pair< T1, T2 > &a, const pair< T1, T2 > &b)
 
template<typename T1 , typename T2 >
bool operator> (const pair< T1, T2 > &a, const pair< T1, T2 > &b)
 
template<typename T1 , typename T2 >
bool operator<= (const pair< T1, T2 > &a, const pair< T1, T2 > &b)
 
template<typename T1 , typename T2 >
bool operator>= (const pair< T1, T2 > &a, const pair< T1, T2 > &b)
 
template<typename T >
exchange (T &object, const T &new_value)
 exchange (const)
 
template<typename T , typename U >
exchange (T &object, const U &new_value)
 
template<typename T >
etl::add_const< T >::type & as_const (T &t)
 as_const
 
template<typename T >
bool operator== (const etl::ivector< T > &lhs, const etl::ivector< T > &rhs)
 
template<typename T >
bool operator!= (const etl::ivector< T > &lhs, const etl::ivector< T > &rhs)
 
template<typename T >
bool operator< (const etl::ivector< T > &lhs, const etl::ivector< T > &rhs)
 
template<typename T >
bool operator> (const etl::ivector< T > &lhs, const etl::ivector< T > &rhs)
 
template<typename T >
bool operator<= (const etl::ivector< T > &lhs, const etl::ivector< T > &rhs)
 
template<typename T >
bool operator>= (const etl::ivector< T > &lhs, const etl::ivector< T > &rhs)
 
template<size_t ARRAY_SIZE>
etl::wstring< ARRAY_SIZE==1 ? 1 :ARRAY_SIZE - 1 > make_string (const wchar_t(&text)[ARRAY_SIZE])
 Hash function. More...
 
template<const size_t MAX_SIZE, const size_t SIZE>
etl::wstring< MAX_SIZE > make_string_with_capacity (const wchar_t(&text)[SIZE])
 Make string with max capacity from string literal or char array.
 

Variables

ETL_DEPRECATED typedef scheduler_policy_sequential_multiple scheduler_policy_sequencial_multiple
 Typedef for backwards compatibility with miss-spelt struct name.
 
const nullopt_t nullopt = {}
 

Detailed Description

A multimap with the capacity defined at compile time.

A multiset with the capacity defined at compile time.

Function Documentation

◆ copy_s()

template<typename TInputIterator , typename TOutputIterator >
etl::enable_if<!etl::is_random_iterator<TInputIterator>::value || !etl::is_random_iterator<TOutputIterator>::value, TOutputIterator>::type etl::copy_s ( TInputIterator  i_begin,
TInputIterator  i_end,
TOutputIterator  o_begin,
TOutputIterator  o_end 
)

copy A safer form of copy where the smallest of the two ranges is used. There is currently no STL equivalent. Specialisation for non random access iterators.

Parameters
i_beginBeginning of the input range.
i_endEnd of the input range.
o_beginBeginning of the output range.
o_endEnd of the output range.

◆ create_default_at() [1/2]

template<typename T >
etl::enable_if<!etl::is_trivially_constructible<T>::value, void>::type etl::create_default_at ( T *  p)

Default contruct an item at address p.

◆ create_default_at() [2/2]

template<typename T , typename TCounter >
etl::enable_if<!etl::is_trivially_constructible<T>::value, void>::type etl::create_default_at ( T *  p,
TCounter &  count 
)

Default contruct an item at address p.

◆ destroy() [1/2]

template<typename TIterator >
etl::enable_if<!etl::is_trivially_destructible<typename etl::iterator_traits<TIterator>::value_type>::value, void>::type etl::destroy ( TIterator  i_begin,
TIterator  i_end 
)

◆ destroy() [2/2]

template<typename TIterator , typename TCounter >
etl::enable_if<!etl::is_trivially_destructible<typename etl::iterator_traits<TIterator>::value_type>::value, void>::type etl::destroy ( TIterator  i_begin,
TIterator  i_end,
TCounter &  count 
)

Destroys a range of items. Debug counter version. https://en.cppreference.com/w/cpp/memory/destroy

◆ destroy_at() [1/2]

template<typename T >
etl::enable_if<!etl::is_trivially_destructible<T>::value, void>::type etl::destroy_at ( T *  p)

◆ destroy_at() [2/2]

template<typename T , typename TCounter >
etl::enable_if<!etl::is_trivially_destructible<T>::value, void>::type etl::destroy_at ( T *  p,
TCounter &  count 
)

Destroys an item at address p. Debug counter version. https://en.cppreference.com/w/cpp/memory/destroy_at

◆ destroy_n() [1/2]

template<typename TIterator , typename TSize >
etl::enable_if<!etl::is_trivially_destructible<typename etl::iterator_traits<TIterator>::value_type>::value, TIterator>::type etl::destroy_n ( TIterator  i_begin,
TSize  n 
)

◆ destroy_n() [2/2]

template<typename TIterator , typename TSize , typename TCounter >
etl::enable_if<!etl::is_trivially_destructible<typename etl::iterator_traits<TIterator>::value_type>::value, TIterator>::type etl::destroy_n ( TIterator  i_begin,
TSize  n,
TCounter &  count 
)

Destroys a number of items. Debug counter version. https://en.cppreference.com/w/cpp/memory/destroy_n

◆ get() [1/2]

template<size_t I, typename T , size_t MAXN>
T& etl::get ( array< T, MAXN > &  a)
inline

Gets a reference to an element in the array.

Template Parameters
IThe index.
TThe type.
MAXNThe array size.
Parameters
aThe array.
Returns
A reference to the element

◆ get() [2/2]

template<size_t I, typename T , size_t MAXN>
const T& etl::get ( const array< T, MAXN > &  a)
inline

Gets a const reference to an element in the array.

Template Parameters
IThe index.
TThe type.
MAXNThe array size.
Parameters
aThe array.
Returns
A const reference to the element

◆ make_string() [1/4]

template<size_t ARRAY_SIZE>
etl::string<ARRAY_SIZE - 1> etl::make_string ( const char(&)  text[ARRAY_SIZE])

Hash function.

Make string from string literal or array

◆ make_string() [2/4]

template<size_t ARRAY_SIZE>
etl::u16string<ARRAY_SIZE == 1 ? 1 : ARRAY_SIZE - 1> etl::make_string ( const char16_t(&)  text[ARRAY_SIZE])

Hash function.

Make string from string literal or array

◆ make_string() [3/4]

template<size_t ARRAY_SIZE>
etl::u32string<ARRAY_SIZE == 1 ? 1 : ARRAY_SIZE - 1> etl::make_string ( const char32_t(&)  text[ARRAY_SIZE])

Hash function.

Make string from string literal or array

◆ make_string() [4/4]

template<size_t ARRAY_SIZE>
etl::wstring<ARRAY_SIZE == 1 ? 1 : ARRAY_SIZE - 1> etl::make_string ( const wchar_t(&)  text[ARRAY_SIZE])

Hash function.

Make string from string literal or array

◆ operator!=() [1/13]

template<typename T , size_t SIZE>
bool etl::operator!= ( const etl::array< T, SIZE > &  lhs,
const etl::array< T, SIZE > &  rhs 
)

Not equal operator.

Parameters
lhsThe first array.
rhsThe second array.
Returns
true if the arrays are not equal, otherwise false

◆ operator!=() [2/13]

template<typename T >
bool etl::operator!= ( const etl::ibasic_string< T > &  lhs,
const etl::ibasic_string< T > &  rhs 
)

Not equal operator.

Parameters
lhsReference to the first string.
rhsReference to the second string.
Returns
true if the arrays are not equal, otherwise false

◆ operator!=() [3/13]

template<typename T >
bool etl::operator!= ( const etl::ibasic_string< T > &  lhs,
const T *  rhs 
)

Not equal operator.

Parameters
lhsReference to the first string.
rhsReference to the second string.
Returns
true if the arrays are not equal, otherwise false

◆ operator!=() [4/13]

template<typename T >
bool etl::operator!= ( const etl::iforward_list< T > &  lhs,
const etl::iforward_list< T > &  rhs 
)

Not equal operator.

Parameters
lhsReference to the first forward_list.
rhsReference to the second forward_list.
Returns
true if the arrays are not equal, otherwise false.

◆ operator!=() [5/13]

template<typename T >
bool etl::operator!= ( const etl::ilist< T > &  lhs,
const etl::ilist< T > &  rhs 
)

Not equal operator.

Parameters
lhsReference to the first list.
rhsReference to the second list.
Returns
true if the arrays are not equal, otherwise false.

◆ operator!=() [6/13]

template<typename TKey , typename TMapped , typename TKeyCompare >
bool etl::operator!= ( const etl::imap< TKey, TMapped, TKeyCompare > &  lhs,
const etl::imap< TKey, TMapped, TKeyCompare > &  rhs 
)

Not equal operator.

Parameters
lhsReference to the first lookup.
rhsReference to the second lookup.
Returns
true if the arrays are not equal, otherwise false

◆ operator!=() [7/13]

template<typename TKey , typename TMapped , typename TKeyCompare >
bool etl::operator!= ( const etl::imultimap< TKey, TMapped, TKeyCompare > &  lhs,
const etl::imultimap< TKey, TMapped, TKeyCompare > &  rhs 
)

Not equal operator.

Parameters
lhsReference to the first lookup.
rhsReference to the second lookup.
Returns
true if the arrays are not equal, otherwise false

◆ operator!=() [8/13]

template<typename TKey , typename TCompare >
bool etl::operator!= ( const etl::imultiset< TKey, TCompare > &  lhs,
const etl::imultiset< TKey, TCompare > &  rhs 
)

Not equal operator.

Parameters
lhsReference to the first lookup.
rhsReference to the second lookup.
Returns
true if the arrays are not equal, otherwise false

◆ operator!=() [9/13]

template<typename TKey , typename TMapped , typename TKeyCompare >
bool etl::operator!= ( const etl::ireference_flat_multimap< TKey, TMapped, TKeyCompare > &  lhs,
const etl::ireference_flat_multimap< TKey, TMapped, TKeyCompare > &  rhs 
)

Not equal operator.

Parameters
lhsReference to the first reference_flat_multimap.
rhsReference to the second reference_flat_multimap.
Returns
true if the arrays are not equal, otherwise false

◆ operator!=() [10/13]

template<typename T , typename TKeyCompare >
bool etl::operator!= ( const etl::ireference_flat_multiset< T, TKeyCompare > &  lhs,
const etl::ireference_flat_multiset< T, TKeyCompare > &  rhs 
)

Not equal operator.

Parameters
lhsReference to the first reference_flat_multiset.
rhsReference to the second reference_flat_multiset.
Returns
true if the arrays are not equal, otherwise false

◆ operator!=() [11/13]

template<typename T , typename TKeyCompare >
bool etl::operator!= ( const etl::ireference_flat_set< T, TKeyCompare > &  lhs,
const etl::ireference_flat_set< T, TKeyCompare > &  rhs 
)

Not equal operator.

Parameters
lhsReference to the first reference_flat_set.
rhsReference to the second reference_flat_set.
Returns
true if the arrays are not equal, otherwise false

◆ operator!=() [12/13]

template<typename TKey , typename TCompare >
bool etl::operator!= ( const etl::iset< TKey, TCompare > &  lhs,
const etl::iset< TKey, TCompare > &  rhs 
)

Not equal operator.

Parameters
lhsReference to the first lookup.
rhsReference to the second lookup.
Returns
true if the arrays are not equal, otherwise false

◆ operator!=() [13/13]

template<typename T >
bool etl::operator!= ( const T *  lhs,
const etl::ibasic_string< T > &  rhs 
)

Not equal operator.

Parameters
lhsReference to the first string.
rhsReference to the second string.
Returns
true if the arrays are not equal, otherwise false

◆ operator+()

template<typename TIterator >
etl::fixed_iterator<TIterator>& etl::operator+ ( etl::fixed_iterator< TIterator > &  lhs,
typename etl::iterator_traits< TIterator >::difference_type   
)
  • difference operator.

◆ operator-() [1/2]

template<typename TIterator >
etl::iterator_traits<TIterator>::difference_type etl::operator- ( etl::fixed_iterator< TIterator > &  lhs,
etl::fixed_iterator< TIterator > &  rhs 
)

◆ operator-() [2/2]

template<typename TIterator >
etl::fixed_iterator<TIterator>& etl::operator- ( etl::fixed_iterator< TIterator > &  lhs,
typename etl::iterator_traits< TIterator >::difference_type   
)
  • difference operator.

◆ operator<() [1/10]

template<typename T , size_t SIZE>
bool etl::operator< ( const etl::array< T, SIZE > &  lhs,
const etl::array< T, SIZE > &  rhs 
)

Less than operator.

Parameters
lhsThe first array.
rhsThe second array.
Returns
true if the first array is lexicographically less than the second, otherwise false

◆ operator<() [2/10]

template<typename T >
bool etl::operator< ( const etl::ibasic_string< T > &  lhs,
const etl::ibasic_string< T > &  rhs 
)

Less than operator.

Parameters
lhsReference to the first string.
rhsReference to the second string.
Returns
true if the first string is lexicographically less than the second, otherwise false

◆ operator<() [3/10]

template<typename T >
bool etl::operator< ( const etl::ibasic_string< T > &  lhs,
const T *  rhs 
)

Less than operator.

Parameters
lhsReference to the first string.
rhsReference to the second string.
Returns
true if the first string is lexicographically less than the second, otherwise false

◆ operator<() [4/10]

template<typename T >
bool etl::operator< ( const etl::iforward_list< T > &  lhs,
const etl::iforward_list< T > &  rhs 
)

Less than operator.

Parameters
lhsReference to the first forward_list.
rhsReference to the second forward_list.
Returns
true if the first forward_list is lexicographically less than the second, otherwise false.

◆ operator<() [5/10]

template<typename T >
bool etl::operator< ( const etl::ilist< T > &  lhs,
const etl::ilist< T > &  rhs 
)

Less than operator.

Parameters
lhsReference to the first list.
rhsReference to the second list.
Returns
true if the first list is lexicographically less than the second, otherwise false.

◆ operator<() [6/10]

template<typename TKey , typename TMapped , typename TKeyCompare >
bool etl::operator< ( const etl::imap< TKey, TMapped, TKeyCompare > &  lhs,
const etl::imap< TKey, TMapped, TKeyCompare > &  rhs 
)

Less than operator.

Parameters
lhsReference to the first list.
rhsReference to the second list.
Returns
true if the first list is lexicographically less than the second, otherwise false.

◆ operator<() [7/10]

template<typename TKey , typename TMapped , typename TKeyCompare >
bool etl::operator< ( const etl::imultimap< TKey, TMapped, TKeyCompare > &  lhs,
const etl::imultimap< TKey, TMapped, TKeyCompare > &  rhs 
)

Less than operator.

Parameters
lhsReference to the first list.
rhsReference to the second list.
Returns
true if the first list is lexicographically less than the second, otherwise false.

◆ operator<() [8/10]

template<typename TKey , typename TCompare >
bool etl::operator< ( const etl::imultiset< TKey, TCompare > &  lhs,
const etl::imultiset< TKey, TCompare > &  rhs 
)

Less than operator.

Parameters
lhsReference to the first list.
rhsReference to the second list.
Returns
true if the first list is lexicographically less than the second, otherwise false.

◆ operator<() [9/10]

template<typename TKey , typename TCompare >
bool etl::operator< ( const etl::iset< TKey, TCompare > &  lhs,
const etl::iset< TKey, TCompare > &  rhs 
)

Less than operator.

Parameters
lhsReference to the first list.
rhsReference to the second list.
Returns
true if the first list is lexicographically less than the second, otherwise false.

◆ operator<() [10/10]

template<typename T >
bool etl::operator< ( const T *  lhs,
const etl::ibasic_string< T > &  rhs 
)

Less than operator.

Parameters
lhsReference to the first string.
rhsReference to the second string.
Returns
true if the first string is lexicographically less than the second, otherwise false

◆ operator<=() [1/10]

template<typename T , size_t SIZE>
bool etl::operator<= ( const etl::array< T, SIZE > &  lhs,
const etl::array< T, SIZE > &  rhs 
)

Less than or equal operator.

Parameters
lhsThe first array.
rhsThe second array.
Returns
true if the first array is lexicographically less than or equal to the second, otherwise false

◆ operator<=() [2/10]

template<typename T >
bool etl::operator<= ( const etl::ibasic_string< T > &  lhs,
const etl::ibasic_string< T > &  rhs 
)

Less than or equal operator.

Parameters
lhsReference to the first string.
rhsReference to the second string.
Returns
true if the first string is lexicographically less than or equal to the second, otherwise false

◆ operator<=() [3/10]

template<typename T >
bool etl::operator<= ( const etl::ibasic_string< T > &  lhs,
const T *  rhs 
)

Less than or equal operator.

Parameters
lhsReference to the first string.
rhsReference to the second string.
Returns
true if the first string is lexicographically less than or equal to the second, otherwise false

◆ operator<=() [4/10]

template<typename T >
bool etl::operator<= ( const etl::iforward_list< T > &  lhs,
const etl::iforward_list< T > &  rhs 
)

Less than or equal operator.

Parameters
lhsReference to the first forward_list.
rhsReference to the second forward_list.
Returns
true if the first forward_list is lexicographically less than or equal to the second, otherwise false.

◆ operator<=() [5/10]

template<typename T >
bool etl::operator<= ( const etl::ilist< T > &  lhs,
const etl::ilist< T > &  rhs 
)

Less than or equal operator.

Parameters
lhsReference to the first list.
rhsReference to the second list.
Returns
true if the first list is lexicographically less than or equal to the second, otherwise false.

◆ operator<=() [6/10]

template<typename TKey , typename TMapped , typename TKeyCompare >
bool etl::operator<= ( const etl::imap< TKey, TMapped, TKeyCompare > &  lhs,
const etl::imap< TKey, TMapped, TKeyCompare > &  rhs 
)

Less than or equal operator.

Parameters
lhsReference to the first list.
rhsReference to the second list.
Returns
true if the first list is lexicographically less than or equal to the second, otherwise false.

◆ operator<=() [7/10]

template<typename TKey , typename TMapped , typename TKeyCompare >
bool etl::operator<= ( const etl::imultimap< TKey, TMapped, TKeyCompare > &  lhs,
const etl::imultimap< TKey, TMapped, TKeyCompare > &  rhs 
)

Less than or equal operator.

Parameters
lhsReference to the first list.
rhsReference to the second list.
Returns
true if the first list is lexicographically less than or equal to the second, otherwise false.

◆ operator<=() [8/10]

template<typename TKey , typename TCompare >
bool etl::operator<= ( const etl::imultiset< TKey, TCompare > &  lhs,
const etl::imultiset< TKey, TCompare > &  rhs 
)

Less than or equal operator.

Parameters
lhsReference to the first list.
rhsReference to the second list.
Returns
true if the first list is lexicographically less than or equal to the second, otherwise false.

◆ operator<=() [9/10]

template<typename TKey , typename TCompare >
bool etl::operator<= ( const etl::iset< TKey, TCompare > &  lhs,
const etl::iset< TKey, TCompare > &  rhs 
)

Less than or equal operator.

Parameters
lhsReference to the first list.
rhsReference to the second list.
Returns
true if the first list is lexicographically less than or equal to the second, otherwise false.

◆ operator<=() [10/10]

template<typename T >
bool etl::operator<= ( const T *  lhs,
const etl::ibasic_string< T > &  rhs 
)

Less than or equal operator.

Parameters
lhsReference to the first string.
rhsReference to the second string.
Returns
true if the first string is lexicographically less than or equal to the second, otherwise false

◆ operator==() [1/13]

template<typename T , size_t SIZE>
bool etl::operator== ( const etl::array< T, SIZE > &  lhs,
const etl::array< T, SIZE > &  rhs 
)

Equal operator.

Parameters
lhsThe first array.
rhsThe second array.
Returns
true if the arrays are equal, otherwise false

◆ operator==() [2/13]

template<typename T >
bool etl::operator== ( const etl::ibasic_string< T > &  lhs,
const etl::ibasic_string< T > &  rhs 
)

Equal operator.

Parameters
lhsReference to the first string.
rhsReference to the second string.
Returns
true if the arrays are equal, otherwise false

◆ operator==() [3/13]

template<typename T >
bool etl::operator== ( const etl::ibasic_string< T > &  lhs,
const T *  rhs 
)

Equal operator.

Parameters
lhsReference to the first string.
rhsReference to the second string.
Returns
true if the arrays are equal, otherwise false

◆ operator==() [4/13]

template<typename T >
bool etl::operator== ( const etl::iforward_list< T > &  lhs,
const etl::iforward_list< T > &  rhs 
)

Equal operator.

Parameters
lhsReference to the first forward_list.
rhsReference to the second forward_list.
Returns
true if the arrays are equal, otherwise false.

◆ operator==() [5/13]

template<typename T >
bool etl::operator== ( const etl::ilist< T > &  lhs,
const etl::ilist< T > &  rhs 
)

Equal operator.

Parameters
lhsReference to the first list.
rhsReference to the second list.
Returns
true if the arrays are equal, otherwise false.

◆ operator==() [6/13]

template<typename TKey , typename TMapped , typename TKeyCompare >
bool etl::operator== ( const etl::imap< TKey, TMapped, TKeyCompare > &  lhs,
const etl::imap< TKey, TMapped, TKeyCompare > &  rhs 
)

Template deduction guides.

Equal operator.

Parameters
lhsReference to the first lookup.
rhsReference to the second lookup.
Returns
true if the arrays are equal, otherwise false

◆ operator==() [7/13]

template<typename TKey , typename TMapped , typename TKeyCompare >
bool etl::operator== ( const etl::imultimap< TKey, TMapped, TKeyCompare > &  lhs,
const etl::imultimap< TKey, TMapped, TKeyCompare > &  rhs 
)

Template deduction guides.

Equal operator.

Parameters
lhsReference to the first lookup.
rhsReference to the second lookup.
Returns
true if the arrays are equal, otherwise false

◆ operator==() [8/13]

template<typename TKey , typename TCompare >
bool etl::operator== ( const etl::imultiset< TKey, TCompare > &  lhs,
const etl::imultiset< TKey, TCompare > &  rhs 
)

Template deduction guides.

Equal operator.

Parameters
lhsReference to the first lookup.
rhsReference to the second lookup.
Returns
true if the arrays are equal, otherwise false

◆ operator==() [9/13]

template<typename TKey , typename TMapped , typename TKeyCompare >
bool etl::operator== ( const etl::ireference_flat_multimap< TKey, TMapped, TKeyCompare > &  lhs,
const etl::ireference_flat_multimap< TKey, TMapped, TKeyCompare > &  rhs 
)

Equal operator.

Parameters
lhsReference to the first reference_flat_multimap.
rhsReference to the second reference_flat_multimap.
Returns
true if the arrays are equal, otherwise false

◆ operator==() [10/13]

template<typename T , typename TKeyCompare >
bool etl::operator== ( const etl::ireference_flat_multiset< T, TKeyCompare > &  lhs,
const etl::ireference_flat_multiset< T, TKeyCompare > &  rhs 
)

Equal operator.

Parameters
lhsReference to the first reference_flat_multiset.
rhsReference to the second reference_flat_multiset.
Returns
true if the arrays are equal, otherwise false

◆ operator==() [11/13]

template<typename T , typename TKeyCompare >
bool etl::operator== ( const etl::ireference_flat_set< T, TKeyCompare > &  lhs,
const etl::ireference_flat_set< T, TKeyCompare > &  rhs 
)

Equal operator.

Parameters
lhsReference to the first reference_flat_set.
rhsReference to the second reference_flat_set.
Returns
true if the arrays are equal, otherwise false

◆ operator==() [12/13]

template<typename TKey , typename TCompare >
bool etl::operator== ( const etl::iset< TKey, TCompare > &  lhs,
const etl::iset< TKey, TCompare > &  rhs 
)

Template deduction guides.

Equal operator.

Parameters
lhsReference to the first lookup.
rhsReference to the second lookup.
Returns
true if the arrays are equal, otherwise false

◆ operator==() [13/13]

template<typename T >
bool etl::operator== ( const T *  lhs,
const etl::ibasic_string< T > &  rhs 
)

Equal operator.

Parameters
lhsReference to the first string.
rhsReference to the second string.
Returns
true if the arrays are equal, otherwise false

◆ operator>() [1/10]

template<typename T , size_t SIZE>
bool etl::operator> ( const etl::array< T, SIZE > &  lhs,
const etl::array< T, SIZE > &  rhs 
)

Greater than operator.

Parameters
lhsThe first array.
rhsThe second array.
Returns
true if the first array is lexicographically greater than the second, otherwise false

◆ operator>() [2/10]

template<typename T >
bool etl::operator> ( const etl::ibasic_string< T > &  lhs,
const etl::ibasic_string< T > &  rhs 
)

Greater than operator.

Parameters
lhsReference to the first string.
rhsReference to the second string.
Returns
true if the first string is lexicographically greater than the second, otherwise false

◆ operator>() [3/10]

template<typename T >
bool etl::operator> ( const etl::ibasic_string< T > &  lhs,
const T *  rhs 
)

Greater than operator.

Parameters
lhsReference to the first string.
rhsReference to the second string.
Returns
true if the first string is lexicographically greater than the second, otherwise false

◆ operator>() [4/10]

template<typename T >
bool etl::operator> ( const etl::iforward_list< T > &  lhs,
const etl::iforward_list< T > &  rhs 
)

Greater than operator.

Parameters
lhsReference to the first forward_list.
rhsReference to the second forward_list.
Returns
true if the first forward_list is lexicographically greater than the second, otherwise false.

◆ operator>() [5/10]

template<typename T >
bool etl::operator> ( const etl::ilist< T > &  lhs,
const etl::ilist< T > &  rhs 
)

Greater than operator.

Parameters
lhsReference to the first list.
rhsReference to the second list.
Returns
true if the first list is lexicographically greater than the second, otherwise false.

◆ operator>() [6/10]

template<typename TKey , typename TMapped , typename TKeyCompare >
bool etl::operator> ( const etl::imap< TKey, TMapped, TKeyCompare > &  lhs,
const etl::imap< TKey, TMapped, TKeyCompare > &  rhs 
)

Greater than operator.

Parameters
lhsReference to the first list.
rhsReference to the second list.
Returns
true if the first list is lexicographically greater than the second, otherwise false.

◆ operator>() [7/10]

template<typename TKey , typename TMapped , typename TKeyCompare >
bool etl::operator> ( const etl::imultimap< TKey, TMapped, TKeyCompare > &  lhs,
const etl::imultimap< TKey, TMapped, TKeyCompare > &  rhs 
)

Greater than operator.

Parameters
lhsReference to the first list.
rhsReference to the second list.
Returns
true if the first list is lexicographically greater than the second, otherwise false.

◆ operator>() [8/10]

template<typename TKey , typename TCompare >
bool etl::operator> ( const etl::imultiset< TKey, TCompare > &  lhs,
const etl::imultiset< TKey, TCompare > &  rhs 
)

Greater than operator.

Parameters
lhsReference to the first list.
rhsReference to the second list.
Returns
true if the first list is lexicographically greater than the second, otherwise false.

◆ operator>() [9/10]

template<typename TKey , typename TCompare >
bool etl::operator> ( const etl::iset< TKey, TCompare > &  lhs,
const etl::iset< TKey, TCompare > &  rhs 
)

Greater than operator.

Parameters
lhsReference to the first list.
rhsReference to the second list.
Returns
true if the first list is lexicographically greater than the second, otherwise false.

◆ operator>() [10/10]

template<typename T >
bool etl::operator> ( const T *  lhs,
const etl::ibasic_string< T > &  rhs 
)

Greater than operator.

Parameters
lhsReference to the first string.
rhsReference to the second string.
Returns
true if the first string is lexicographically greater than the second, otherwise false

◆ operator>=() [1/10]

template<typename T , size_t SIZE>
bool etl::operator>= ( const etl::array< T, SIZE > &  lhs,
const etl::array< T, SIZE > &  rhs 
)

Greater than or equal operator.

Parameters
lhsThe first array.
rhsThe second array.
Returns
true if the first array is lexicographically greater than or equal to the second, otherwise false

◆ operator>=() [2/10]

template<typename T >
bool etl::operator>= ( const etl::ibasic_string< T > &  lhs,
const etl::ibasic_string< T > &  rhs 
)

Greater than or equal operator.

Parameters
lhsReference to the first string.
rhsReference to the second string.
Returns
true if the first string is lexicographically greater than or equal to the second, otherwise false

◆ operator>=() [3/10]

template<typename T >
bool etl::operator>= ( const etl::ibasic_string< T > &  lhs,
const T *  rhs 
)

Greater than or equal operator.

Parameters
lhsReference to the first string.
rhsReference to the second string.
Returns
true if the first string is lexicographically greater than or equal to the second, otherwise false

◆ operator>=() [4/10]

template<typename T >
bool etl::operator>= ( const etl::iforward_list< T > &  lhs,
const etl::iforward_list< T > &  rhs 
)

Greater than or equal operator.

Parameters
lhsReference to the first forward_list.
rhsReference to the second forward_list.
Returns
true if the first forward_list is lexicographically greater than or equal to the second, otherwise false.

◆ operator>=() [5/10]

template<typename T >
bool etl::operator>= ( const etl::ilist< T > &  lhs,
const etl::ilist< T > &  rhs 
)

Greater than or equal operator.

Parameters
lhsReference to the first list.
rhsReference to the second list.
Returns
true if the first list is lexicographically greater than or equal to the second, otherwise false.

◆ operator>=() [6/10]

template<typename TKey , typename TMapped , typename TKeyCompare >
bool etl::operator>= ( const etl::imap< TKey, TMapped, TKeyCompare > &  lhs,
const etl::imap< TKey, TMapped, TKeyCompare > &  rhs 
)

Greater than or equal operator.

Parameters
lhsReference to the first list.
rhsReference to the second list.
Returns
true if the first list is lexicographically greater than or equal to the second, otherwise false.

◆ operator>=() [7/10]

template<typename TKey , typename TMapped , typename TKeyCompare >
bool etl::operator>= ( const etl::imultimap< TKey, TMapped, TKeyCompare > &  lhs,
const etl::imultimap< TKey, TMapped, TKeyCompare > &  rhs 
)

Greater than or equal operator.

Parameters
lhsReference to the first list.
rhsReference to the second list.
Returns
true if the first list is lexicographically greater than or equal to the second, otherwise false.

◆ operator>=() [8/10]

template<typename TKey , typename TCompare >
bool etl::operator>= ( const etl::imultiset< TKey, TCompare > &  lhs,
const etl::imultiset< TKey, TCompare > &  rhs 
)

Greater than or equal operator.

Parameters
lhsReference to the first list.
rhsReference to the second list.
Returns
true if the first list is lexicographically greater than or equal to the second, otherwise false.

◆ operator>=() [9/10]

template<typename TKey , typename TCompare >
bool etl::operator>= ( const etl::iset< TKey, TCompare > &  lhs,
const etl::iset< TKey, TCompare > &  rhs 
)

Greater than or equal operator.

Parameters
lhsReference to the first list.
rhsReference to the second list.
Returns
true if the first list is lexicographically greater than or equal to the second, otherwise false.

◆ operator>=() [10/10]

template<typename T >
bool etl::operator>= ( const T *  lhs,
const etl::ibasic_string< T > &  rhs 
)

Greater than or equal operator.

Parameters
lhsReference to the first string.
rhsReference to the second string.
Returns
true if the first string is lexicographically greater than or equal to the second, otherwise false

◆ reverse()

template<typename TIString >
void etl::reverse ( TIString &  s)

reverse Reverse a string

◆ round_ceiling_scaled()

template<const size_t SCALING, typename T >
T etl::round_ceiling_scaled ( value)

Round to more positive integer.

Parameters
valueScaled integral.
Returns
Scaled, rounded integral.

◆ round_ceiling_unscaled()

template<const size_t SCALING, typename T >
T etl::round_ceiling_unscaled ( value)

Round to more positive integer.

Parameters
valueScaled integral.
Returns
Unscaled, rounded integral.

◆ round_floor_scaled()

template<const size_t SCALING, typename T >
T etl::round_floor_scaled ( value)

Round to more negative integer.

Parameters
valueScaled integral.
Returns
Scaled, rounded integral.

◆ round_floor_unscaled()

template<const size_t SCALING, typename T >
T etl::round_floor_unscaled ( value)

Round to more negative integer.

Parameters
valueScaled integral.
Returns
Unscaled, rounded integral.

◆ round_half_down_scaled()

template<const size_t SCALING, typename T >
T etl::round_half_down_scaled ( value)

Round to nearest integer. 'Half' value is rounded down (to zero). Uses 'symmetric down' rounding.

Parameters
valueScaled integral.
Returns
Scaled, rounded integral.

◆ round_half_down_unscaled()

template<const size_t SCALING, typename T >
T etl::round_half_down_unscaled ( value)

Round to nearest integer. 'Half' value is rounded down (to zero). Uses 'symmetric down' rounding.

Parameters
valueScaled integral.
Returns
Unscaled, rounded integral.

◆ round_half_even_scaled()

template<const size_t SCALING, typename T >
T etl::round_half_even_scaled ( value)

Round to nearest integer. 'Half' value is rounded to even integral. Also known as 'Banker's Rounding'.

Parameters
valueScaled integral.
Returns
Scaled, rounded integral.

◆ round_half_even_unscaled()

template<const size_t SCALING, typename T >
T etl::round_half_even_unscaled ( value)

Round to nearest integer. 'Half' value is rounded to even integral. Also known as 'Banker's Rounding'.

Parameters
valueScaled integral.
Returns
Unscaled, rounded integral.
Examples
For.

◆ round_half_odd_scaled()

template<const size_t SCALING, typename T >
T etl::round_half_odd_scaled ( value)

Round to nearest integer. 'Half' value is rounded to odd integral. Also known as 'Banker's Rounding'.

Parameters
valueScaled integral.
Returns
Scaled, rounded integral.

◆ round_half_odd_unscaled()

template<const size_t SCALING, typename T >
T etl::round_half_odd_unscaled ( value)

Round to nearest integer. 'Half' value is rounded to odd integral. Also known as 'Banker's Rounding'.

Parameters
valueScaled integral.
Returns
Unscaled, rounded integral.

◆ round_half_up_scaled()

template<const size_t SCALING, typename T >
T etl::round_half_up_scaled ( value)

Round to nearest integer. 'Half' value is rounded up (to infinity). Uses 'symmetric up' rounding.

Parameters
valueScaled integral.
Returns
Scaled, rounded integral.

◆ round_half_up_unscaled()

template<const size_t SCALING, typename T >
T etl::round_half_up_unscaled ( value)

Round to nearest integer. 'Half' value is rounded up (to infinity). Uses 'symmetric up' rounding.

Parameters
valueScaled integral.
Returns
Unscaled, rounded integral.

◆ round_infinity_scaled()

template<const size_t SCALING, typename T >
T etl::round_infinity_scaled ( value)

Round toward infinity.

Parameters
valueScaled integral.
Returns
Ccaled, rounded integral.

◆ round_infinity_unscaled()

template<const size_t SCALING, typename T >
T etl::round_infinity_unscaled ( value)

Round toward infinity.

Parameters
valueScaled integral.
Returns
Unscaled, rounded integral.

◆ round_zero_scaled()

template<const size_t SCALING, typename T >
T etl::round_zero_scaled ( value)

Round toward zero.

Parameters
valueScaled integral.
Returns
Scaled, rounded integral.

◆ round_zero_unscaled()

template<const size_t SCALING, typename T >
T etl::round_zero_unscaled ( value)

Round toward zero.

Parameters
valueScaled integral.
Returns
Unscaled, rounded integral.

◆ swap() [1/2]

template<typename T , const size_t SIZE>
void etl::swap ( etl::array< T, SIZE > &  lhs,
etl::array< T, SIZE > &  rhs 
)

Template deduction guides.

Overloaded swap for etl::array<T, SIZE>

Parameters
lhsThe first array.
rhsThe second array.

◆ swap() [2/2]

template<typename T >
void etl::swap ( etl::circular_buffer_ext< T > &  lhs,
etl::circular_buffer_ext< T > &  rhs 
)

Template deduction guides.

Overloaded swap for etl::circular_buffer_ext<T, 0>

◆ to_string() [1/24]

template<typename T >
etl::enable_if<etl::is_same<T, etl::istring>::value, const etl::istring&>::type etl::to_string ( const etl::istring value,
T &  str,
const etl::format_spec format,
bool  append = false 
)

Supplied format spec. etl::istring

◆ to_string() [2/24]

template<typename T >
etl::enable_if<etl::is_same<T, etl::iu16string>::value, const etl::iu16string&>::type etl::to_string ( const etl::iu16string value,
T &  str,
const etl::u16format_spec format,
bool  append = false 
)

Supplied format spec. etl::iu16string

◆ to_string() [3/24]

template<typename T >
etl::enable_if<etl::is_same<T, etl::iu32string>::value, const etl::iu32string&>::type etl::to_string ( const etl::iu32string value,
T &  str,
const etl::u32format_spec format,
bool  append = false 
)

Supplied format spec. etl::iu32string

◆ to_string() [4/24]

template<typename T >
etl::enable_if<etl::is_same<T, etl::iwstring>::value, const etl::iwstring&>::type etl::to_string ( const etl::iwstring value,
T &  str,
const etl::wformat_spec format,
bool  append = false 
)

Supplied format spec. etl::iwstring

◆ to_string() [5/24]

template<typename T >
etl::enable_if<etl::is_same<T, etl::istring>::value, const etl::istring&>::type etl::to_string ( const T &  value,
etl::istring str,
bool  append = false 
)

Default format spec. etl::istring

◆ to_string() [6/24]

template<typename T >
etl::enable_if<etl::is_same<T, etl::iu16string>::value, const etl::iu16string&>::type etl::to_string ( const T &  value,
etl::iu16string str,
bool  append = false 
)

Default format spec. etl::iu16string

◆ to_string() [7/24]

template<typename T >
etl::enable_if<etl::is_same<T, etl::iu32string>::value, const etl::iu32string&>::type etl::to_string ( const T &  value,
etl::iu32string str,
bool  append = false 
)

Default format spec. etl::iu32string

◆ to_string() [8/24]

template<typename T >
etl::enable_if<etl::is_same<T, etl::iwstring>::value, const etl::iwstring&>::type etl::to_string ( const T &  value,
etl::iwstring str,
bool  append = false 
)

Default format spec. etl::iwstring

◆ to_string() [9/24]

template<typename T >
etl::enable_if<!etl::is_same<T, etl::istring>::value && !etl::is_same<T, etl::string_view>::value, const etl::istring&>::type etl::to_string ( const T  value,
etl::istring str,
bool  append = false 
)

Default format spec. !etl::istring && !etl::string_view

◆ to_string() [10/24]

template<typename T >
etl::enable_if<!etl::is_same<T, etl::istring>::value && !etl::is_same<T, etl::string_view>::value, const etl::istring&>::type etl::to_string ( const T  value,
etl::istring str,
const etl::format_spec format,
bool  append = false 
)

Supplied format spec. !etl::istring && !etl::string_view

◆ to_string() [11/24]

template<typename T >
etl::enable_if<!etl::is_same<T, etl::iu16string>::value && !etl::is_same<T, etl::u16string_view>::value, const etl::iu16string&>::type etl::to_string ( const T  value,
etl::iu16string str,
bool  append = false 
)

Default format spec. !etl::iu16string && !etl::u16string_view

◆ to_string() [12/24]

template<typename T >
etl::enable_if<!etl::is_same<T, etl::iu16string>::value && !etl::is_same<T, etl::u16string_view>::value, const etl::iu16string&>::type etl::to_string ( const T  value,
etl::iu16string str,
const etl::u16format_spec format,
bool  append = false 
)

Supplied format spec. !etl::iu16string && !etl::u16string_view

◆ to_string() [13/24]

template<typename T >
etl::enable_if<!etl::is_same<T, etl::iu32string>::value && !etl::is_same<T, etl::u32string_view>::value, const etl::iu32string&>::type etl::to_string ( const T  value,
etl::iu32string str,
bool  append = false 
)

Default format spec. !etl::iu32string && !etl::u32string_view

◆ to_string() [14/24]

template<typename T >
etl::enable_if<!etl::is_same<T, etl::iu32string>::value && !etl::is_same<T, etl::u32string_view>::value, const etl::iu32string&>::type etl::to_string ( const T  value,
etl::iu32string str,
const etl::u32format_spec format,
bool  append = false 
)

Supplied format spec. !etl::iu32string && !etl::u32string_view

◆ to_string() [15/24]

template<typename T >
etl::enable_if<!etl::is_same<T, etl::iwstring>::value && !etl::is_same<T, etl::wstring_view>::value, const etl::iwstring&>::type etl::to_string ( const T  value,
etl::iwstring str,
bool  append = false 
)

Default format spec. !etl::iwstring && !etl::wstring_view

◆ to_string() [16/24]

template<typename T >
etl::enable_if<!etl::is_same<T, etl::iwstring>::value && !etl::is_same<T, etl::wstring_view>::value, const etl::iwstring&>::type etl::to_string ( const T  value,
etl::iwstring str,
const etl::wformat_spec format,
bool  append = false 
)

Supplied format spec. !etl::iwstring && !etl::wstring_view

◆ to_string() [17/24]

template<typename T >
etl::enable_if<etl::is_same<T, etl::string_view>::value, const etl::istring&>::type etl::to_string ( value,
etl::istring str,
bool  append = false 
)

Default format spec. etl::string_view

◆ to_string() [18/24]

template<typename T >
etl::enable_if<etl::is_same<T, etl::string_view>::value, const etl::istring&>::type etl::to_string ( value,
etl::istring str,
const etl::format_spec format,
bool  append = false 
)

Supplied format spec. etl::string_view

◆ to_string() [19/24]

template<typename T >
etl::enable_if<etl::is_same<T, etl::u16string_view>::value, const etl::iu16string&>::type etl::to_string ( value,
etl::iu16string str,
bool  append = false 
)

Default format spec. etl::u16string_view

◆ to_string() [20/24]

template<typename T >
etl::enable_if<etl::is_same<T, etl::u16string_view>::value, const etl::iu16string&>::type etl::to_string ( value,
etl::iu16string str,
const etl::u16format_spec format,
bool  append = false 
)

Supplied format spec. etl::u16string_view

◆ to_string() [21/24]

template<typename T >
etl::enable_if<etl::is_same<T, etl::u32string_view>::value, const etl::iu32string&>::type etl::to_string ( value,
etl::iu32string str,
bool  append = false 
)

Default format spec. etl::u32string_view

◆ to_string() [22/24]

template<typename T >
etl::enable_if<etl::is_same<T, etl::u32string_view>::value, const etl::iu32string&>::type etl::to_string ( value,
etl::iu32string str,
const etl::u32format_spec format,
bool  append = false 
)

Supplied format spec. etl::u32string_view

◆ to_string() [23/24]

template<typename T >
etl::enable_if<etl::is_same<T, etl::wstring_view>::value, const etl::iwstring&>::type etl::to_string ( value,
etl::iwstring str,
bool  append = false 
)

Default format spec. etl::wstring_view

◆ to_string() [24/24]

template<typename T >
etl::enable_if<etl::is_same<T, etl::wstring_view>::value, const etl::iwstring&>::type etl::to_string ( value,
etl::iwstring str,
const etl::wformat_spec format,
bool  append = false 
)

Supplied format spec. etl::wstring_view

◆ trim()

template<typename TIString >
void etl::trim ( TIString &  s,
typename TIString::const_pointer  delimiters 
)

trim_delimiters Trim left and right of trim_characters

◆ trim_from()

template<typename TIString >
void etl::trim_from ( TIString &  s,
typename TIString::const_pointer  trim_characters 
)

trim_from Trim left and right of trim_characters

◆ trim_from_left()

template<typename TIString >
void etl::trim_from_left ( TIString &  s,
typename TIString::const_pointer  trim_characters 
)

trim_from_left Trim left of trim_characters

◆ trim_from_right()

template<typename TIString >
void etl::trim_from_right ( TIString &  s,
typename TIString::const_pointer  trim_characters 
)

trim_from_right Trim right of trim_characters

◆ trim_from_view()

template<typename TStringView >
TStringView etl::trim_from_view ( const TStringView &  view,
typename TStringView::const_pointer  trim_characters 
)

trim_from_view Trim left and right of trim_characters

◆ trim_from_view_left()

template<typename TStringView >
TStringView etl::trim_from_view_left ( const TStringView &  view,
typename TStringView::const_pointer  trim_characters 
)

trim_from_view_left Trim left of trim_characters

◆ trim_from_view_right()

template<typename TStringView >
TStringView etl::trim_from_view_right ( const TStringView &  view,
typename TStringView::const_pointer  trim_characters 
)

trim_from_view_right Trim right of trim_characters

◆ trim_left()

template<typename TIString >
void etl::trim_left ( TIString &  s,
typename TIString::const_pointer  delimiters 
)

trim_left Trim left, up to, but not including, delimiters.

◆ trim_view()

template<typename TStringView >
TStringView etl::trim_view ( const TStringView &  view,
typename TStringView::const_pointer  delimiters 
)

trim_view Trim left and right of trim_characters

◆ trim_view_left()

template<typename TStringView >
TStringView etl::trim_view_left ( const TStringView &  view,
typename TStringView::const_pointer  delimiters 
)

trim_view_left View trim left, up to, but not including, delimiters.

◆ trim_view_whitespace()

template<typename TStringView >
TStringView etl::trim_view_whitespace ( const TStringView &  view)

trim_view_whitespace Trim both ends of whitespace

◆ trim_view_whitespace_left()

template<typename TStringView >
TStringView etl::trim_view_whitespace_left ( TStringView &  s)

trim_view_whitespace_left Trim left of whitespace

◆ trim_view_whitespace_right()

template<typename TStringView >
TStringView etl::trim_view_whitespace_right ( TStringView &  view)

trim_view_whitespace_right Trim right of whitespace

◆ trim_whitespace()

template<typename TIString >
void etl::trim_whitespace ( TIString &  s)

trim_whitespace Trim both ends of whitespace

◆ trim_whitespace_left()

template<typename TIString >
void etl::trim_whitespace_left ( TIString &  s)

trim_whitespace_left Trim left of whitespace

◆ trim_whitespace_right()

template<typename TIString >
void etl::trim_whitespace_right ( TIString &  s)

trim_whitespace_right Trim firght of whitespace

◆ uninitialized_default_construct() [1/2]

template<typename TOutputIterator >
etl::enable_if<!etl::is_trivially_constructible<typename etl::iterator_traits<TOutputIterator>::value_type>::value, void>::type etl::uninitialized_default_construct ( TOutputIterator  o_begin,
TOutputIterator  o_end 
)

Default initialises a range of objects to uninitialised memory. https://en.cppreference.com/w/cpp/memory/uninitialized_default_construct

◆ uninitialized_default_construct() [2/2]

template<typename TOutputIterator , typename TCounter >
etl::enable_if<!etl::is_trivially_constructible<typename etl::iterator_traits<TOutputIterator>::value_type>::value, void>::type etl::uninitialized_default_construct ( TOutputIterator  o_begin,
TOutputIterator  o_end,
TCounter &  count 
)

Default initialises a range of objects to uninitialised memory. https://en.cppreference.com/w/cpp/memory/uninitialized_default_construct Debug counter version.

◆ uninitialized_default_construct_n() [1/2]

template<typename TOutputIterator , typename TSize >
etl::enable_if<!etl::is_trivially_constructible<typename etl::iterator_traits<TOutputIterator>::value_type>::value, TOutputIterator>::type etl::uninitialized_default_construct_n ( TOutputIterator  o_begin,
TSize  n 
)

Default initialises N objects to uninitialised memory. https://en.cppreference.com/w/cpp/memory/uninitialized_default_construct_n

◆ uninitialized_default_construct_n() [2/2]

template<typename TOutputIterator , typename TSize , typename TCounter >
etl::enable_if<!etl::is_trivially_constructible<typename etl::iterator_traits<TOutputIterator>::value_type>::value, TOutputIterator>::type etl::uninitialized_default_construct_n ( TOutputIterator  o_begin,
TSize  n,
TCounter &  count 
)

Default initialises N objects to uninitialised memory. https://en.cppreference.com/w/cpp/memory/uninitialized_default_construct_n Debug counter version.

◆ uninitialized_value_construct()

template<typename TOutputIterator >
etl::enable_if<!etl::is_trivially_constructible<typename etl::iterator_traits<TOutputIterator>::value_type>::value, void>::type etl::uninitialized_value_construct ( TOutputIterator  o_begin,
TOutputIterator  o_end 
)

Default initialises a range of objects to uninitialised memory. https://en.cppreference.com/w/cpp/memory/uninitialized_value_construct

Variable Documentation

◆ nullopt

const nullopt_t etl::nullopt = {}

A null option.