Embedded Template Library 1.0
Loading...
Searching...
No Matches
etl Namespace Reference

bitset_ext More...

Namespaces

namespace  private_basic_string
 
namespace  private_correlation
 Correlation Type.
 
namespace  private_covariance
 Covariance Type.
 
namespace  private_standard_deviation
 Standard Deviation Type.
 
namespace  private_variance
 Variance Type.
 
namespace  state_chart_traits
 Simple Finite State Machine Types.
 

Classes

struct  add_const
 add_const More...
 
struct  add_const< const T >
 
struct  add_cv
 add_cv More...
 
struct  add_lvalue_reference
 add_lvalue_reference More...
 
struct  add_pointer
 add_pointer More...
 
struct  add_volatile
 add_volatile More...
 
struct  add_volatile< volatile T >
 
struct  aligned_storage
 
struct  aligned_storage_as
 
class  alignment_error
 Memory misalignment exception. More...
 
class  alignment_exception
 Exception base for alignment. More...
 
struct  alignment_of
 add_rvalue_reference More...
 
struct  alignment_of< const void >
 
struct  alignment_of< void >
 
class  array
 
class  array_exception
 
class  array_out_of_range
 
class  array_view
 Array view. More...
 
class  array_view_bounds
 
class  array_view_exception
 The base class for array_view exceptions. More...
 
class  array_view_uninitialised
 
class  array_wrapper
 Array wrapper. More...
 
class  array_wrapper_bounds
 
class  array_wrapper_exception
 The base class for array_wrapper exceptions. More...
 
class  back_insert_iterator
 Turns assignment into push_back. More...
 
class  bad_variant_access
 
class  base64
 Common Base64 definitions. More...
 
class  base64_exception
 Exception base for base64. More...
 
class  base64_invalid_data
 Illegal character exception. More...
 
class  base64_invalid_decode_input_length
 Invalid decode input length exception. More...
 
class  base64_overflow
 buffer overflow exception. More...
 
class  base64_rfc2152_decoder
 Base64 RFC-2152 Decoder. More...
 
class  base64_rfc2152_encoder
 Base64 RFC-2152 Encoder. More...
 
class  base64_rfc3501_decoder
 Base64 RFC-3501 Decoder. More...
 
class  base64_rfc3501_encoder
 Base64 RFC-3501 Encoder. More...
 
class  base64_rfc4648_decoder
 Base64 RFC-4648 Decoder. More...
 
class  base64_rfc4648_encoder
 Base64 RFC-4648 Encoder. More...
 
class  base64_rfc4648_padding_decoder
 Base64 RFC-4648-Padding Decoder. More...
 
class  base64_rfc4648_padding_encoder
 Base64 RFC-4648-Padding Encoder. More...
 
class  base64_rfc4648_url_decoder
 Base64 RFC-4648-URL Decoder. More...
 
class  base64_rfc4648_url_encoder
 Base64 RFC-4648-URL Encoder. More...
 
class  base64_rfc4648_url_padding_decoder
 Base64 RFC-4648-URL-Padding Decoder. More...
 
class  base64_rfc4648_url_padding_encoder
 Base64 RFC-4648-URL_Padding Encoder. More...
 
class  basic_format_spec
 basic_format_spec More...
 
class  basic_string_stream
 
class  basic_string_view
 String view. More...
 
struct  bidirectional_iterator_tag
 
struct  bidirectional_link
 A bidirectional link. More...
 
struct  binary_and
 
class  binary_exception
 
struct  binary_function
 
struct  binary_not
 
struct  binary_or
 
class  binary_out_of_range
 
struct  binary_xor
 
class  binder1st
 
class  binder2nd
 
struct  bit
 
struct  bit_and
 
struct  bit_not
 
struct  bit_or
 
class  bit_stream
 
class  bit_stream_reader
 Reads bit streams. More...
 
class  bit_stream_writer
 Writes bits streams. More...
 
struct  bit_xor
 
class  bitset
 Bitset forward declaration. More...
 
class  bitset< 0U, unsigned char >
 Specialisation for zero bits. More...
 
class  bitset_exception
 
class  bitset_impl
 
class  bitset_impl< TElement, etl::bitset_storage_model::Multi >
 
class  bitset_impl< TElement, etl::bitset_storage_model::Single >
 
class  bitset_invalid_buffer
 
class  bitset_nullptr
 
class  bitset_overflow
 
struct  bitset_storage_model
 
class  bitset_string_too_small
 
class  bitset_type_too_small
 
class  bloom_filter
 
struct  bool_constant
 
class  bresenham_line
 
class  bsd_checksum
 BSD Checksum. More...
 
class  byte
 The byte class. More...
 
class  byte_stream_reader
 
class  byte_stream_writer
 Encodes a byte stream. More...
 
class  callback
 
class  callback_service
 
class  callback_timer
 The callback timer. More...
 
class  callback_timer_atomic
 The callback timer. More...
 
struct  callback_timer_data
 The configuration of a timer. More...
 
class  callback_timer_interrupt
 The callback timer. More...
 
class  callback_timer_locked
 The callback timer. More...
 
struct  char_traits
 Character traits for any character type. More...
 
struct  char_traits_types
 
struct  char_traits_types< char >
 
struct  char_traits_types< char16_t >
 
struct  char_traits_types< char32_t >
 
struct  char_traits_types< signed char >
 
struct  char_traits_types< unsigned char >
 
struct  char_traits_types< wchar_t >
 
class  checksum
 Standard Checksum. More...
 
struct  checksum_policy_bsd
 BSD checksum policy. More...
 
struct  checksum_policy_parity
 Parity checksum policy. More...
 
struct  checksum_policy_sum
 Standard addition checksum policy. More...
 
struct  checksum_policy_xor
 Standard XOR checksum policy. More...
 
struct  checksum_policy_xor_rotate
 XOR-rotate checksum policy. More...
 
class  circular_buffer
 
class  circular_buffer_base
 
class  circular_buffer_empty
 Empty exception for the circular_buffer. More...
 
class  circular_buffer_exception
 Exception for the circular_buffer. More...
 
class  circular_buffer_ext
 
class  circular_buffer_incompatible_type
 Incompatible type exception. More...
 
struct  combinations
 
struct  compare
 
struct  conditional
 conditional More...
 
struct  conditional< false, T, F >
 
struct  conditional_integral_constant
 conditional_integral_constant More...
 
struct  conditional_integral_constant< false, T, TRUE_VALUE, FALSE_VALUE >
 
struct  conditional_integral_constant< true, T, TRUE_VALUE, FALSE_VALUE >
 
class  constant
 
struct  coordinate_2d
 integer_sequence More...
 
class  correlation
 Correlation. More...
 
struct  correlation_type
 
class  covariance
 Covariance. More...
 
struct  covariance_type
 
class  crc1
 
class  crc16_a_t
 
class  crc16_arc_t
 
class  crc16_aug_ccitt_t
 
class  crc16_buypass_t
 
class  crc16_ccitt_t
 
class  crc16_cdma2000_t
 
class  crc16_dds110_t
 
class  crc16_dect_r_t
 
class  crc16_dect_x_t
 
class  crc16_dnp_t
 
class  crc16_en13757_t
 
class  crc16_genibus_t
 
class  crc16_kermit_t
 
class  crc16_m17_t
 
class  crc16_maxim_t
 
class  crc16_mcrf4xx_t
 
class  crc16_modbus_t
 
class  crc16_profibus_t
 
class  crc16_riello_t
 
class  crc16_t
 
class  crc16_t10dif_t
 
class  crc16_teledisk_t
 
class  crc16_tms37157_t
 
class  crc16_usb_t
 
class  crc16_x25_t
 
class  crc16_xmodem_t
 
struct  crc1_policy
 
class  crc32_bzip2_t
 
class  crc32_c_t
 
class  crc32_d_t
 
class  crc32_jamcrc_t
 
class  crc32_mpeg2_t
 
class  crc32_posix_t
 
class  crc32_q_t
 
class  crc32_t
 
class  crc32_xfer_t
 
class  crc64_ecma_t
 
class  crc8_ccitt_t
 
class  crc8_cdma2000_t
 
class  crc8_darc_t
 
class  crc8_dvbs2_t
 
class  crc8_ebu_t
 
class  crc8_icode_t
 
class  crc8_itu_t
 
class  crc8_j1850_t
 
class  crc8_j1850_zero_t
 
class  crc8_maxim_t
 
class  crc8_rohc_t
 
class  crc8_wcdma_t
 
class  crc_type
 Basic parameterised CRC type. More...
 
class  cyclic_value
 Provides a value that cycles between two limits. More...
 
class  cyclic_value< T, First, Last, false >
 
class  cyclic_value< T, First, Last, true >
 
class  debounce
 
class  debounce< 0, 0, 0 >
 
class  debounce< VALID_COUNT, 0, 0 >
 
class  debounce< VALID_COUNT, HOLD_COUNT, 0 >
 
class  debug_count
 
struct  decay
 decay More...
 
struct  default_delete
 
struct  default_delete< T[]>
 
class  delegate
 Declaration. More...
 
class  delegate< TReturn(TParam)>
 
class  delegate< TReturn(TParams...)>
 Specialisation. More...
 
class  delegate< TReturn(void)>
 Specialisation for void parameter. More...
 
class  delegate_exception
 The base class for delegate exceptions. More...
 
class  delegate_observable
 
class  delegate_observer_exception
 
class  delegate_observer_list_full
 
class  delegate_service
 
struct  delegate_tag
 
class  delegate_uninitialised
 The exception thrown when the delegate is uninitialised. More...
 
class  deque
 
class  deque_base
 
class  deque_empty
 
class  deque_exception
 
class  deque_full
 
class  deque_incompatible_type
 
class  deque_out_of_bounds
 
struct  divides
 
struct  enable_if
 enable_if More...
 
struct  endian
 
struct  endianness
 
struct  equal_to
 
class  ETL_FINAL
 
class  exception
 
class  expected
 Expected type. More...
 
class  expected< void, TError >
 Specialisation for void value type. More...
 
class  expected_exception
 Base exception for et::expected. More...
 
class  expected_invalid
 expected_invalid More...
 
struct  extent
 extent More...
 
struct  factorial
 
struct  factorial< 0 >
 
class  factory
 
class  factory_cannot_create
 
class  factory_did_not_create
 
class  factory_exception
 
struct  fibonacci
 
struct  fibonacci< 0 >
 
struct  fibonacci< 1 >
 
class  fixed_iterator
 
class  fixed_sized_memory_block_allocator
 
class  flags
 
class  flat_map
 
class  flat_map_exception
 
class  flat_map_full
 
class  flat_map_out_of_bounds
 
class  flat_multimap
 
class  flat_multimap_exception
 
class  flat_multimap_full
 
class  flat_multiset
 
class  flat_multiset_exception
 
class  flat_multiset_full
 
class  flat_multiset_iterator
 
class  flat_set
 
class  flat_set_exception
 
class  flat_set_full
 
class  flat_set_iterator
 
class  fnv_1_32
 
class  fnv_1_64
 
struct  fnv_1_policy_32
 
struct  fnv_1_policy_64
 
class  fnv_1a_32
 
class  fnv_1a_64
 
struct  fnv_1a_policy_32
 
struct  fnv_1a_policy_64
 
struct  forward_iterator_tag
 
struct  forward_link
 A forward link. More...
 
class  forward_list
 
class  forward_list_base
 
class  forward_list_empty
 
class  forward_list_exception
 
class  forward_list_ext
 Template deduction guides. More...
 
class  forward_list_full
 
class  forward_list_iterator
 
class  forward_list_no_pool
 
class  frame_check_sequence
 
class  front_insert_iterator
 Turns assignment into a push_front. More...
 
class  fsm
 The FSM class. More...
 
class  fsm_exception
 Base exception class for FSM. More...
 
class  fsm_not_started
 Exception for message received but not started. More...
 
class  fsm_null_state_exception
 Exception for null state pointer. 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  fsm_state_composite_state_change_forbidden
 Exception for forbidden state changes. 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  function
 
class  function< TObject, void >
 
class  function< void, TParameter >
 
class  function< void, void >
 
class  function_fp
 
class  function_fv
 
class  function_imp
 
class  function_imv
 
class  function_mp
 
class  function_mv
 
class  gamma_decode
 Gamma decode function. More...
 
class  gamma_encode
 Gamma encode function. More...
 
class  generic_pool
 
class  generic_pool_ext
 
struct  greater
 
struct  greater_equal
 
class  hash_exception
 
class  hash_finalised
 
class  hfsm
 
class  histogram
 Histogram with a compile time start index. More...
 
class  histogram< TKey, TCount, Max_Size, etl::integral_limits< int32_t >::max >
 Histogram with a run time start index. More...
 
class  ibase64_decoder
 Base64 Decoder. More...
 
class  ibase64_encoder
 Base64 Encoder. More...
 
class  ibasic_string
 
class  ibitset
 
class  icache
 
class  icallback_timer
 Interface for callback timer. More...
 
class  icallback_timer_atomic
 Interface for callback timer. More...
 
class  icallback_timer_interrupt
 Interface for callback timer. More...
 
class  icallback_timer_locked
 Interface for callback timer. More...
 
class  icircular_buffer
 
class  ideque
 
class  iflat_map
 
class  iflat_multimap
 
class  iflat_multiset
 
class  iflat_set
 
class  iforward_list
 
class  ifsm_state
 Interface class for FSM states. More...
 
class  ifunction
 
class  ifunction< void >
 
class  iindirect_vector
 
class  ilist
 
class  imap
 
class  imemory_block_allocator
 The interface for a memory block pool. More...
 
class  imessage
 
class  imessage_bus
 Interface for message bus. More...
 
class  imessage_router
 This is the base of all message routers. More...
 
class  imessage_router_registry
 This is the base of all message router registries. More...
 
class  imessage_timer
 Interface for message timer. More...
 
class  imessage_timer_interrupt
 Interface for message timer. More...
 
class  imessage_timer_locked
 Interface for message timer. More...
 
class  imulti_range
 The base class for multi_range. More...
 
class  imultimap
 
class  imultiset
 
struct  in_place_index_t
 
struct  in_place_t
 in_place disambiguation tags. More...
 
struct  in_place_type_t
 
class  indirect_vector
 
class  indirect_vector_buffer_missmatch
 
class  indirect_vector_ext
 Template deduction guides. More...
 
struct  input_iterator_tag
 
class  instance_count
 
struct  integral_constant
 integral_constant More...
 
struct  integral_limits
 
struct  integral_limits< char >
 
struct  integral_limits< int >
 
struct  integral_limits< long >
 
struct  integral_limits< long long >
 
struct  integral_limits< short >
 
struct  integral_limits< signed char >
 
struct  integral_limits< unsigned char >
 
struct  integral_limits< unsigned int >
 
struct  integral_limits< unsigned long >
 
struct  integral_limits< unsigned long long >
 
struct  integral_limits< unsigned short >
 
class  intrusive_forward_list
 
class  intrusive_forward_list_base
 
class  intrusive_forward_list_empty
 
class  intrusive_forward_list_exception
 
class  intrusive_forward_list_index_exception
 
class  intrusive_forward_list_iterator_exception
 
class  intrusive_forward_list_unsorted
 
class  intrusive_forward_list_value_is_already_linked
 
class  intrusive_list
 
class  intrusive_list_base
 
class  intrusive_list_empty
 
class  intrusive_list_exception
 
class  intrusive_list_iterator_exception
 
class  intrusive_list_unsorted
 
class  intrusive_list_value_is_already_linked
 
class  intrusive_queue
 
class  intrusive_queue_base
 
class  intrusive_queue_empty
 
class  intrusive_queue_exception
 
class  intrusive_queue_value_is_already_linked
 
class  intrusive_stack
 
class  intrusive_stack_base
 
class  intrusive_stack_empty
 
class  intrusive_stack_exception
 
class  intrusive_stack_value_is_already_linked
 
class  invert
 Invert. More...
 
class  io_port_ro
 Read only port. More...
 
class  io_port_ro< T, 0 >
 
class  io_port_rw
 Read write port. More...
 
class  io_port_rw< T, 0 >
 
class  io_port_wo
 Write only port. More...
 
class  io_port_wo< T, 0 >
 
class  io_port_wos
 Write only port with shadow register. More...
 
class  io_port_wos< T, 0 >
 
class  ipool
 
class  ipriority_queue
 This is the base for all priority queues that contain a particular type. More...
 
class  iqueue
 This is the base for all queues that contain a particular type. More...
 
class  iqueue_lockable
 This is the base for all queues that contain a particular type. More...
 
class  iqueue_spsc_isr
 This is the base for all queue_spsc_isrs that contain a particular type. More...
 
class  iqueue_spsc_locked
 This is the base for all queue_spsc_locked that contain a particular type. More...
 
class  iqueue_spsc_locked_base
 
class  ireference_counted_message
 
class  ireference_counted_message_pool
 Interface for a reference counted message pool. More...
 
class  ireference_counted_object
 Base for all reference counted objects. More...
 
class  ireference_counter
 The base of all reference counters. More...
 
class  ireference_flat_map
 
class  ireference_flat_multimap
 
class  ireference_flat_multiset
 
class  ireference_flat_set
 
struct  is_arithmetic
 is_arithmetic More...
 
struct  is_array
 is_array More...
 
struct  is_assignable
 conjunction More...
 
struct  is_base_of
 is_base_of More...
 
struct  is_bidirectional_iterator
 
struct  is_bidirectional_iterator_concept
 
struct  is_bidirectional_link
 
struct  is_class
 is_class More...
 
struct  is_compound
 is_compound More...
 
struct  is_const
 is_const More...
 
struct  is_const< const T >
 
struct  is_const< const volatile T >
 
struct  is_copy_constructible
 
struct  is_default_constructible
 
struct  is_delegate
 is_delegate More...
 
struct  is_floating_point
 is_floating_point More...
 
struct  is_forward_iterator
 
struct  is_forward_iterator_concept
 
struct  is_forward_link
 
struct  is_fundamental
 is_fundamental More...
 
struct  is_imessage
 Is T an etl::imessage? More...
 
struct  is_input_iterator
 
struct  is_input_iterator_concept
 
struct  is_integral
 is_integral More...
 
struct  is_integral< bool >
 
struct  is_integral< char >
 
struct  is_integral< const T >
 
struct  is_integral< const volatile T >
 
struct  is_integral< int >
 
struct  is_integral< long >
 
struct  is_integral< long long >
 
struct  is_integral< short >
 
struct  is_integral< signed char >
 
struct  is_integral< unsigned char >
 
struct  is_integral< unsigned int >
 
struct  is_integral< unsigned long >
 
struct  is_integral< unsigned long long >
 
struct  is_integral< unsigned short >
 
struct  is_integral< volatile T >
 
struct  is_integral< wchar_t >
 
struct  is_lvalue_assignable
 
struct  is_lvalue_reference
 is_lvalue_reference More...
 
struct  is_message
 Is T ultimately derived from etl::imessage? More...
 
struct  is_message_base
 Is T a base of etl::message<T> More...
 
struct  is_message_router
 Is T ultimately derived from etl::imessage_router? More...
 
struct  is_message_type
 Is T an etl::message<> or derived from etl::message<> More...
 
struct  is_move_constructible
 
struct  is_output_iterator
 
struct  is_output_iterator_concept
 
struct  is_pod
 is_rvalue_reference More...
 
struct  is_pointer
 is_pointer More...
 
struct  is_power_of_2
 
struct  is_power_of_2< 0 >
 
struct  is_power_of_2< 1 >
 
struct  is_random_access_iterator
 
struct  is_random_access_iterator_concept
 
struct  is_random_iterator
 
struct  is_random_iterator_concept
 
struct  is_reference
 is_reference More...
 
struct  is_same
 is_same More...
 
struct  is_signed
 is_signed More...
 
struct  is_signed< char >
 
struct  is_tree_link
 
struct  is_trivially_constructible
 
struct  is_trivially_copy_assignable
 
struct  is_trivially_copy_constructible
 
struct  is_trivially_copyable
 
struct  is_trivially_destructible
 
struct  is_unsigned
 is_unsigned More...
 
struct  is_user_message_base
 Is T a user defined base of etl::message<T> and not an etl::imessage. More...
 
struct  is_visitor
 
struct  is_void
 is_void More...
 
struct  is_volatile
 is_volatile More...
 
struct  is_volatile< const volatile T >
 
struct  is_volatile< volatile T >
 
class  ischeduler
 Scheduler base. More...
 
class  iset
 
class  istack
 This is the base for all stacks that contain a particular type. More...
 
class  istate_chart
 For non-void parameter types. More...
 
class  istate_chart< void >
 For void parameter types. More...
 
struct  iterator
 iterator More...
 
struct  iterator_traits
 
struct  iterator_traits< const T *, void >
 
struct  iterator_traits< T *, void >
 
class  iunordered_map
 
class  iunordered_multimap
 
class  iunordered_multiset
 
class  iunordered_set
 
class  ivector
 
class  ivector< const T * >
 
class  ivector< T * >
 
class  jenkins
 jenkins More...
 
struct  jenkins_policy
 
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. \ingroup largest. 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 >
 
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  largest
 
struct  largest_alignment
 
struct  largest_alignment< T1, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void >
 
struct  largest_type
 
struct  largest_type< T1, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void >
 
struct  less
 
struct  less_equal
 
class  limiter
 Limiter. More...
 
class  link_exception
 Link exception. More...
 
class  list
 A templated list implementation that uses a fixed size buffer. More...
 
class  list_base
 
class  list_empty
 
class  list_exception
 
class  list_ext
 Template deduction guides. More...
 
class  list_full
 
class  list_iterator
 
class  list_no_pool
 
class  list_unsorted
 
class  lock_guard
 
struct  log
 
struct  log10
 
struct  log2
 
struct  log< 0, BASE >
 
struct  log< 1, BASE >
 
struct  logical_and
 
struct  logical_not
 
struct  logical_or
 
class  lsb_mask
 
struct  make_signed
 make_signed More...
 
struct  make_unsigned
 make_unsigned More...
 
class  map
 A templated map implementation that uses a fixed size buffer. More...
 
class  map_base
 
class  map_exception
 
class  map_full
 
class  map_iterator
 
class  map_out_of_bounds
 
struct  math
 
struct  max_value_for_nbits
 Definition for non-zero NBITS. More...
 
struct  max_value_for_nbits< 0 >
 Specialisation for when NBITS == 0. More...
 
class  mean
 Mean. More...
 
class  mem_cast
 mem_cast More...
 
class  mem_cast_exception
 The base class for array_wrapper exceptions. More...
 
class  mem_cast_nullptr_exception
 The exception thrown when the pointer is null. More...
 
class  mem_cast_ptr
 mem_cast_ptr More...
 
class  mem_cast_size_exception
 The exception thrown when the type size is too large. More...
 
struct  mem_cast_types
 
class  message
 
class  message_broker
 Message broker. More...
 
class  message_bus
 The message bus. More...
 
class  message_bus_exception
 Base exception class for message bus. More...
 
class  message_bus_too_many_subscribers
 Too many subscribers. More...
 
class  message_exception
 
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_producer
 This router can be used as a producer-only of messages, such an interrupt routine. More...
 
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 >
 
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  message_router_registry
 Message router registry. More...
 
class  message_router_registry_exception
 Base exception class for message router registry. More...
 
class  message_router_registry_full
 The registry is full. More...
 
class  message_tag
 
class  message_timer
 The message timer. More...
 
struct  message_timer_data
 The configuration of a timer. More...
 
class  message_timer_interrupt
 The message timer. More...
 
class  message_timer_locked
 The message timer. More...
 
struct  minus
 
struct  modulus
 
struct  monostate
 
class  msb_mask
 
class  multi_range
 
class  multi_range_circular_reference
 Circular reference exception. More...
 
class  multi_range_exception
 Exception for the multi_range. More...
 
class  multi_span
 
class  multimap
 A templated multimap implementation that uses a fixed size buffer. More...
 
class  multimap_base
 
class  multimap_exception
 
class  multimap_full
 
class  multimap_iterator
 
class  multimap_out_of_bounds
 
struct  multiplies
 
class  multiset
 A templated multiset implementation that uses a fixed size buffer. More...
 
class  multiset_base
 
class  multiset_exception
 
class  multiset_full
 
class  multiset_iterator
 
class  multiset_out_of_bounds
 
class  murmur3
 
class  mutex
 This mutex class is implemented using CMSIS's RTOS2 mutexes. More...
 
struct  negate
 
struct  negation
 negation More...
 
struct  not_equal_to
 
class  not_unlinked_exception
 not unlinked exception. More...
 
class  null_message_router
 This router can be used as a sink for messages or a 'null source' router. More...
 
class  null_type
 
class  nullopt_t
 
class  nullptr_t
 
class  numeric_limits
 
class  observable
 
class  observer
 
class  observer< T1 >
 
class  observer< T1, T2 >
 
class  observer< T1, T2, T3 >
 
class  observer< T1, T2, T3, T4 >
 
class  observer< T1, T2, T3, T4, T5 >
 
class  observer< T1, T2, T3, T4, T5, T6 >
 
class  observer< T1, T2, T3, T4, T5, T6, T7 >
 
class  observer< void >
 
class  observer_exception
 
class  observer_list_full
 
class  optional
 
class  optional_exception
 
class  optional_invalid
 
struct  output_iterator_tag
 
class  packet
 
struct  pair
 pair holds two objects of arbitrary type More...
 
struct  parameter_type
 Determine how to pass parameters. More...
 
class  parity_checksum
 Parity Checksum. More...
 
class  pearson
 
struct  permutations
 
struct  permutations< NV, 0 >
 
class  persistent_message
 
struct  plus
 
class  poly_span
 Poly Span - Fixed Extent. More...
 
class  poly_span< TBase, etl::dynamic_extent >
 Poly Span - Dynamic Extent. More...
 
class  pool
 
class  pool_element_size
 
class  pool_exception
 
class  pool_ext
 
class  pool_no_allocation
 
class  pool_object_not_in_pool
 
struct  power
 
struct  power< NV, 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  power_of_2_round_up
 
struct  power_of_2_round_up< 0 >
 
class  priority_queue
 
class  priority_queue_exception
 
class  priority_queue_full
 
class  priority_queue_iterator
 
class  pseudo_moving_average
 
class  pseudo_moving_average< T, 0, SCALING_, true, false >
 
class  pseudo_moving_average< T, 0U, 1U, false, true >
 
class  pseudo_moving_average< T, SAMPLE_SIZE_, 1U, false, true >
 
class  pseudo_moving_average< T, SAMPLE_SIZE_, SCALING_, true, false >
 
class  push_insert_iterator
 Turns assignment into a push. More...
 
class  pvoidvector
 
class  quantize
 Quantize . More...
 
class  queue
 
class  queue_base
 
class  queue_empty
 
class  queue_exception
 
class  queue_full
 
class  queue_lockable
 
class  queue_lockable_base
 
class  queue_spsc_isr
 
class  queue_spsc_isr_base
 
class  queue_spsc_locked
 
struct  radix
 
class  random
 
struct  random_access_iterator_tag
 
class  random_clcg
 
class  random_lcg
 
class  random_lsfr
 
class  random_mwc
 
class  random_pcg
 
class  random_xorshift
 
struct  rank
 rank More...
 
struct  ratio
 
class  reference_count_overrun
 
class  reference_counted_message
 
class  reference_counted_message_pool
 A pool for allocating reference counted messages. More...
 
class  reference_counted_message_pool_allocation_failure
 Exception if the allocation failed. More...
 
class  reference_counted_message_pool_exception
 Exception type for etl::reference_counted_message_pool. More...
 
class  reference_counted_message_pool_release_failure
 Exception if the release failed. More...
 
class  reference_counted_object
 
class  reference_counter
 A specific type of reference counter. More...
 
class  reference_counter< void >
 A specialisation for a counter type of void. More...
 
class  reference_counting_exception
 
class  reference_flat_map
 
class  reference_flat_multimap
 
class  reference_flat_multiset
 
class  reference_flat_set
 
class  reference_wrapper
 
struct  remove_all_extents
 remove_all_extents More...
 
struct  remove_const
 remove_const More...
 
struct  remove_const< const T >
 
struct  remove_cv
 remove_cv More...
 
struct  remove_cvref
 remove_cvref More...
 
struct  remove_extent
 remove_extent More...
 
struct  remove_pointer
 remove_pointer More...
 
struct  remove_pointer< const T * >
 
struct  remove_pointer< const T *const >
 
struct  remove_pointer< const volatile T * >
 
struct  remove_pointer< const volatile T *const >
 
struct  remove_pointer< T * >
 
struct  remove_pointer< T *const >
 
struct  remove_pointer< volatile T * >
 
struct  remove_pointer< volatile T *const >
 
struct  remove_reference
 remove_reference More...
 
struct  remove_reference< T & >
 
struct  remove_volatile
 remove_volatile More...
 
struct  remove_volatile< volatile T >
 
class  rescale
 Rescale function. More...
 
struct  reverse_bits_const
 
struct  reverse_bits_const< int16_t, Value >
 
struct  reverse_bits_const< int32_t, Value >
 
struct  reverse_bits_const< int64_t, Value >
 
struct  reverse_bits_const< uint16_t, Value >
 
struct  reverse_bits_const< uint32_t, Value >
 
struct  reverse_bits_const< uint64_t, Value >
 
class  reverse_iterator
 
class  rms
 Standard Deviation. More...
 
struct  scaled_rounding_t
 
class  scheduler
 Scheduler. More...
 
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...
 
struct  scheduler_policy_highest_priority
 
struct  scheduler_policy_most_work
 
struct  scheduler_policy_sequential_multiple
 
struct  scheduler_policy_sequential_single
 
class  scheduler_too_many_tasks_exception
 'Too many tasks' exception. More...
 
struct  select1st
 Functor to select pair::first. More...
 
struct  select2nd
 Functor to select pair::second. More...
 
class  set
 A templated set implementation that uses a fixed size buffer. More...
 
class  set_base
 
class  set_exception
 
class  set_full
 
class  set_iterator
 
class  set_out_of_bounds
 
class  shared_message
 
struct  signed_type
 Defines one of five signed types that has the same size as T. More...
 
class  singleton
 Creates . More...
 
class  singleton_base
 
class  singleton_base_already_created
 Singleton instance already exists. More...
 
class  singleton_base_exception
 Base singleton error exception. More...
 
class  singleton_base_not_created
 Singleton not created error exception. More...
 
class  singleton_exception
 Base singleton error exception. More...
 
class  singleton_factory
 
class  singleton_not_created
 Singleton not created error exception. More...
 
struct  size_of
 size_of More...
 
struct  size_of< void >
 
struct  size_type_lookup
 
struct  size_type_lookup< etl::memory_model::MEMORY_MODEL_HUGE >
 
struct  size_type_lookup< etl::memory_model::MEMORY_MODEL_LARGE >
 
struct  size_type_lookup< etl::memory_model::MEMORY_MODEL_MEDIUM >
 
struct  size_type_lookup< etl::memory_model::MEMORY_MODEL_SMALL >
 
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_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  smallest_type
 
struct  smallest_type< T1, void, void, void, void, void, void, void, void, void, void, void, void, void, void, void >
 
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_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...
 
class  span
 Span - Fixed Extent. More...
 
class  span< T, etl::dynamic_extent >
 Span - Dynamic Extent. More...
 
class  sparse_histogram
 Histogram for sparse keys. More...
 
struct  sqrt
 Calculates the smallest value that, when squared, will be not greater than VALUE. More...
 
class  stack
 
class  stack_base
 
class  stack_empty
 
class  stack_exception
 
class  stack_full
 
class  standard_deviation
 Standard Deviation. More...
 
struct  standard_deviation_type
 
class  state_chart
 
class  state_chart< TObject, void >
 
class  state_chart_ct
 
class  state_chart_ctp
 
class  string
 
class  string_base
 
class  string_empty
 
class  string_exception
 
class  string_ext
 
class  string_iterator
 
class  string_out_of_bounds
 
struct  string_pad_direction
 string_pad_direction More...
 
class  string_truncation
 
class  string_view_bounds
 
class  string_view_exception
 The base class for basic_string_view exceptions. More...
 
class  string_view_uninitialised
 
class  successor
 Adds successor traits to a class. More...
 
class  successor_exception
 Exception for the successor. More...
 
class  successor_invalid
 Invalid exception for successor. More...
 
class  task
 Task. More...
 
class  task_exception
 Base exception class for task. More...
 
class  threshold
 Threshold. More...
 
struct  timer
 Common definitions for the timer framework. More...
 
class  to_arithmetic_result
 Status values for to_arithmetic. More...
 
struct  to_arithmetic_status
 Status values for to_arithmetic. More...
 
struct  tree_link
 A binary tree link. More...
 
class  type_def
 
struct  type_id_lookup
 
struct  type_id_pair
 The type/id pair type to use for type/id lookup template parameters. More...
 
struct  type_identity
 
struct  type_select
 
struct  type_select< T0 >
 
struct  type_select< T0, T1 >
 
struct  type_select< T0, T1, T2 >
 
struct  type_select< T0, T1, T2, T3 >
 
struct  type_select< T0, T1, T2, T3, T4 >
 
struct  type_select< T0, T1, T2, T3, T4, T5 >
 
struct  type_select< T0, T1, T2, T3, T4, T5, T6 >
 
struct  type_select< T0, T1, T2, T3, T4, T5, T6, T7 >
 
struct  type_select< T0, T1, T2, T3, T4, T5, T6, T7, T8 >
 
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, T9, T10 >
 
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, T11, T12 >
 
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, T13, T14 >
 
struct  type_type_lookup
 
struct  type_type_pair
 The type/type pair type to use for type/type lookup template parameters. More...
 
class  type_with_alignment
 
struct  types
 A set of templates to allow related types to be derived. More...
 
struct  types< T & >
 
struct  types< T * >
 
struct  types< T *const >
 
class  u16string
 
class  u16string_ext
 
class  u32string
 
class  u32string_ext
 
class  u8string
 
class  u8string_ext
 
class  unaligned_type_buffer_size
 Buffer size exception. More...
 
struct  unaligned_type_exception
 
struct  unary_function
 
struct  unexpect_t
 unexpect_t More...
 
class  unexpected
 
class  unhandled_message_exception
 
class  unique_ptr
 
class  unique_ptr< T[], TDeleter >
 
class  unordered_map
 A templated unordered_map implementation that uses a fixed size buffer. More...
 
class  unordered_map_exception
 
class  unordered_map_full
 
class  unordered_map_iterator
 
class  unordered_map_out_of_range
 
class  unordered_multimap
 A templated unordered_multimap implementation that uses a fixed size buffer. More...
 
class  unordered_multimap_exception
 
class  unordered_multimap_full
 
class  unordered_multimap_iterator
 
class  unordered_multimap_out_of_range
 
class  unordered_multiset
 A templated unordered_multiset implementation that uses a fixed size buffer. More...
 
class  unordered_multiset_exception
 
class  unordered_multiset_full
 
class  unordered_multiset_iterator
 
class  unordered_multiset_out_of_range
 
class  unordered_set
 A templated unordered_set implementation that uses a fixed size buffer. More...
 
class  unordered_set_exception
 
class  unordered_set_full
 
class  unordered_set_iterator
 
class  unordered_set_out_of_range
 
struct  unsigned_type
 Defines one of five unsigned types that has the same size as T. More...
 
class  variance
 Variance. More...
 
struct  variance_type
 
class  variant
 
struct  variant_alternative
 
struct  variant_alternative< tIndex, TVariant const >
 
struct  variant_alternative< tIndex, TVariant const volatile >
 
struct  variant_alternative< tIndex, TVariant volatile >
 
class  variant_exception
 
class  variant_incorrect_type_exception
 
class  variant_not_a_base_exception
 
class  variant_pool
 
class  variant_pool_ext
 
class  vector_base
 
class  vector_empty
 
class  vector_exception
 
class  vector_full
 
class  vector_incompatible_type
 
class  vector_out_of_bounds
 
class  visitable
 
class  visitable< T1 >
 
class  visitable< T1, T2 >
 
class  visitable< T1, T2, T3 >
 
class  visitor
 
class  visitor< T1 >
 
class  visitor< T1, T2 >
 
class  visitor< T1, T2, T3 >
 
class  visitor< T1, T2, T3, T4 >
 
class  visitor< T1, T2, T3, T4, T5 >
 
class  visitor< T1, T2, T3, T4, T5, T6 >
 
class  visitor< T1, T2, T3, T4, T5, T6, T7 >
 
class  visitor< T1, T2, T3, T4, T5, T6, T7, T8 >
 
class  visitor< T1, T2, T3, T4, T5, T6, T7, T8, T9 >
 
class  visitor< T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 >
 
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, T11, T12 >
 
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, T13, T14 >
 
class  visitor< T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15 >
 
struct  visitor_tag
 
struct  whitespace
 whitespace More...
 
struct  whitespace< char >
 
struct  whitespace< wchar_t >
 
class  wstring
 
class  wstring_ext
 
class  xor_checksum
 XOR Checksum. More...
 
class  xor_rotate_checksum
 XOR-shift Checksum. More...
 

Typedefs

using atomic_bool = etl::atomic< bool >
 
using atomic_char = etl::atomic< char >
 
using atomic_schar = etl::atomic< signed char >
 
using atomic_uchar = etl::atomic< unsigned char >
 
using atomic_short = etl::atomic< short >
 
using atomic_ushort = etl::atomic< unsigned short >
 
using atomic_int = etl::atomic< int >
 
using atomic_uint = etl::atomic< unsigned int >
 
using atomic_long = etl::atomic< long >
 
using atomic_ulong = etl::atomic< unsigned long >
 
using atomic_llong = etl::atomic< long long >
 
using atomic_ullong = etl::atomic< unsigned long long >
 
using atomic_wchar_t = etl::atomic< wchar_t >
 
using atomic_uint16_t = etl::atomic< uint16_t >
 
using atomic_int16_t = etl::atomic< int16_t >
 
using atomic_uint32_t = etl::atomic< uint32_t >
 
using atomic_int32_t = etl::atomic< int32_t >
 
using atomic_uint64_t = etl::atomic< uint64_t >
 
using atomic_int64_t = etl::atomic< int64_t >
 
using atomic_int_least8_t = etl::atomic< int_least8_t >
 
using atomic_uint_least8_t = etl::atomic< uint_least8_t >
 
using atomic_int_least16_t = etl::atomic< int_least16_t >
 
using atomic_uint_least16_t = etl::atomic< uint_least16_t >
 
using atomic_int_least32_t = etl::atomic< int_least32_t >
 
using atomic_uint_least32_t = etl::atomic< uint_least32_t >
 
using atomic_int_least64_t = etl::atomic< int_least64_t >
 
using atomic_uint_least64_t = etl::atomic< uint_least64_t >
 
using atomic_int_fast8_t = etl::atomic< int_fast8_t >
 
using atomic_uint_fast8_t = etl::atomic< uint_fast8_t >
 
using atomic_int_fast16_t = etl::atomic< int_fast16_t >
 
using atomic_uint_fast16_t = etl::atomic< uint_fast16_t >
 
using atomic_int_fast32_t = etl::atomic< int_fast32_t >
 
using atomic_uint_fast32_t = etl::atomic< uint_fast32_t >
 
using atomic_int_fast64_t = etl::atomic< int_fast64_t >
 
using atomic_uint_fast64_t = etl::atomic< uint_fast64_t >
 
using atomic_intptr_t = etl::atomic< intptr_t >
 
using atomic_uintptr_t = etl::atomic< uintptr_t >
 
using atomic_size_t = etl::atomic< size_t >
 
using atomic_ptrdiff_t = etl::atomic< ptrdiff_t >
 
using atomic_intmax_t = etl::atomic< intmax_t >
 
using atomic_uintmax_t = etl::atomic< uintmax_t >
 
template<typename T >
using atomic = std::atomic< T >
 
using memory_order = std::memory_order
 
typedef etl::crc16_t< 256Ucrc16_t256
 
typedef etl::crc16_t< 16Ucrc16_t16
 
typedef etl::crc16_t< 4Ucrc16_t4
 
typedef crc16_t256 crc16
 
typedef etl::crc16_a_t< 256Ucrc16_a_t256
 
typedef etl::crc16_a_t< 16Ucrc16_a_t16
 
typedef etl::crc16_a_t< 4Ucrc16_a_t4
 
typedef crc16_a_t256 crc16_a
 
typedef etl::crc16_arc_t< 256Ucrc16_arc_t256
 
typedef etl::crc16_arc_t< 16Ucrc16_arc_t16
 
typedef etl::crc16_arc_t< 4Ucrc16_arc_t4
 
typedef crc16_arc_t256 crc16_arc
 
typedef etl::crc16_aug_ccitt_t< 256Ucrc16_aug_ccitt_t256
 
typedef etl::crc16_aug_ccitt_t< 16Ucrc16_aug_ccitt_t16
 
typedef etl::crc16_aug_ccitt_t< 4Ucrc16_aug_ccitt_t4
 
typedef crc16_aug_ccitt_t256 crc16_aug_ccitt
 
typedef etl::crc16_buypass_t< 256Ucrc16_buypass_t256
 
typedef etl::crc16_buypass_t< 16Ucrc16_buypass_t16
 
typedef etl::crc16_buypass_t< 4Ucrc16_buypass_t4
 
typedef crc16_buypass_t256 crc16_buypass
 
typedef etl::crc16_ccitt_t< 256Ucrc16_ccitt_t256
 
typedef etl::crc16_ccitt_t< 16Ucrc16_ccitt_t16
 
typedef etl::crc16_ccitt_t< 4Ucrc16_ccitt_t4
 
typedef crc16_ccitt_t256 crc16_ccitt
 
typedef etl::crc16_cdma2000_t< 256Ucrc16_cdma2000_t256
 
typedef etl::crc16_cdma2000_t< 16Ucrc16_cdma2000_t16
 
typedef etl::crc16_cdma2000_t< 4Ucrc16_cdma2000_t4
 
typedef crc16_cdma2000_t256 crc16_cdma2000
 
typedef etl::crc16_dds110_t< 256Ucrc16_dds110_t256
 
typedef etl::crc16_dds110_t< 16Ucrc16_dds110_t16
 
typedef etl::crc16_dds110_t< 4Ucrc16_dds110_t4
 
typedef crc16_dds110_t256 crc16_dds110
 
typedef etl::crc16_dect_r_t< 256Ucrc16_dect_r_t256
 
typedef etl::crc16_dect_r_t< 16Ucrc16_dect_r_t16
 
typedef etl::crc16_dect_r_t< 4Ucrc16_dect_r_t4
 
typedef crc16_dect_r_t256 crc16_dectr
 
typedef etl::crc16_dect_x_t< 256Ucrc16_dect_x_t256
 
typedef etl::crc16_dect_x_t< 16Ucrc16_dect_x_t16
 
typedef etl::crc16_dect_x_t< 4Ucrc16_dect_x_t4
 
typedef crc16_dect_x_t256 crc16_dectx
 
typedef etl::crc16_dnp_t< 256Ucrc16_dnp_t256
 
typedef etl::crc16_dnp_t< 16Ucrc16_dnp_t16
 
typedef etl::crc16_dnp_t< 4Ucrc16_dnp_t4
 
typedef crc16_dnp_t256 crc16_dnp
 
typedef etl::crc16_en13757_t< 256Ucrc16_en13757_t256
 
typedef etl::crc16_en13757_t< 16Ucrc16_en13757_t16
 
typedef etl::crc16_en13757_t< 4Ucrc16_en13757_t4
 
typedef crc16_en13757_t256 crc16_en13757
 
typedef etl::crc16_genibus_t< 256Ucrc16_genibus_t256
 
typedef etl::crc16_genibus_t< 16Ucrc16_genibus_t16
 
typedef etl::crc16_genibus_t< 4Ucrc16_genibus_t4
 
typedef crc16_genibus_t256 crc16_genibus
 
typedef etl::crc16_kermit_t< 256Ucrc16_kermit_t256
 
typedef etl::crc16_kermit_t< 16Ucrc16_kermit_t16
 
typedef etl::crc16_kermit_t< 4Ucrc16_kermit_t4
 
typedef crc16_kermit_t256 crc16_kermit
 
typedef etl::crc16_m17_t< 256Ucrc16_m17_t256
 
typedef etl::crc16_m17_t< 16Ucrc16_m17_t16
 
typedef etl::crc16_m17_t< 4Ucrc16_m17_t4
 
typedef crc16_m17_t256 crc16_m17
 
typedef etl::crc16_maxim_t< 256Ucrc16_maxim_t256
 
typedef etl::crc16_maxim_t< 16Ucrc16_maxim_t16
 
typedef etl::crc16_maxim_t< 4Ucrc16_maxim_t4
 
typedef crc16_maxim_t256 crc16_maxim
 
typedef etl::crc16_mcrf4xx_t< 256Ucrc16_mcrf4xx_t256
 
typedef etl::crc16_mcrf4xx_t< 16Ucrc16_mcrf4xx_t16
 
typedef etl::crc16_mcrf4xx_t< 4Ucrc16_mcrf4xx_t4
 
typedef crc16_mcrf4xx_t256 crc16_mcrf4xx
 
typedef etl::crc16_modbus_t< 256Ucrc16_modbus_t256
 
typedef etl::crc16_modbus_t< 16Ucrc16_modbus_t16
 
typedef etl::crc16_modbus_t< 4Ucrc16_modbus_t4
 
typedef crc16_modbus_t256 crc16_modbus
 
typedef etl::crc16_profibus_t< 256Ucrc16_profibus_t256
 
typedef etl::crc16_profibus_t< 16Ucrc16_profibus_t16
 
typedef etl::crc16_profibus_t< 4Ucrc16_profibus_t4
 
typedef crc16_profibus_t256 crc16_profibus
 
typedef etl::crc16_riello_t< 256Ucrc16_riello_t256
 
typedef etl::crc16_riello_t< 16Ucrc16_riello_t16
 
typedef etl::crc16_riello_t< 4Ucrc16_riello_t4
 
typedef crc16_riello_t256 crc16_riello
 
typedef etl::crc16_t10dif_t< 256Ucrc16_t10dif_t256
 
typedef etl::crc16_t10dif_t< 16Ucrc16_t10dif_t16
 
typedef etl::crc16_t10dif_t< 4Ucrc16_t10dif_t4
 
typedef crc16_t10dif_t256 crc16_t10dif
 
typedef etl::crc16_teledisk_t< 256Ucrc16_teledisk_t256
 
typedef etl::crc16_teledisk_t< 16Ucrc16_teledisk_t16
 
typedef etl::crc16_teledisk_t< 4Ucrc16_teledisk_t4
 
typedef crc16_teledisk_t256 crc16_teledisk
 
typedef etl::crc16_tms37157_t< 256Ucrc16_tms37157_t256
 
typedef etl::crc16_tms37157_t< 16Ucrc16_tms37157_t16
 
typedef etl::crc16_tms37157_t< 4Ucrc16_tms37157_t4
 
typedef crc16_tms37157_t256 crc16_tms37157
 
typedef etl::crc16_usb_t< 256Ucrc16_usb_t256
 
typedef etl::crc16_usb_t< 16Ucrc16_usb_t16
 
typedef etl::crc16_usb_t< 4Ucrc16_usb_t4
 
typedef crc16_usb_t256 crc16_usb
 
typedef etl::crc16_x25_t< 256Ucrc16_x25_t256
 
typedef etl::crc16_x25_t< 16Ucrc16_x25_t16
 
typedef etl::crc16_x25_t< 4Ucrc16_x25_t4
 
typedef crc16_x25_t256 crc16_x25
 
typedef etl::crc16_xmodem_t< 256Ucrc16_xmodem_t256
 
typedef etl::crc16_xmodem_t< 16Ucrc16_xmodem_t16
 
typedef etl::crc16_xmodem_t< 4Ucrc16_xmodem_t4
 
typedef crc16_xmodem_t256 crc16_xmodem
 
typedef etl::crc32_t< 256Ucrc32_t256
 
typedef etl::crc32_t< 16Ucrc32_t16
 
typedef etl::crc32_t< 4Ucrc32_t4
 
typedef crc32_t256 crc32
 
typedef etl::crc32_bzip2_t< 256Ucrc32_bzip2_t256
 
typedef etl::crc32_bzip2_t< 16Ucrc32_bzip2_t16
 
typedef etl::crc32_bzip2_t< 4Ucrc32_bzip2_t4
 
typedef crc32_bzip2_t256 crc32_bzip2
 
typedef etl::crc32_c_t< 256Ucrc32_c_t256
 
typedef etl::crc32_c_t< 16Ucrc32_c_t16
 
typedef etl::crc32_c_t< 4Ucrc32_c_t4
 
typedef crc32_c_t256 crc32_c
 
typedef etl::crc32_d_t< 256Ucrc32_d_t256
 
typedef etl::crc32_d_t< 16Ucrc32_d_t16
 
typedef etl::crc32_d_t< 4Ucrc32_d_t4
 
typedef crc32_d_t256 crc32_d
 
typedef etl::crc32_jamcrc_t< 256Ucrc32_jamcrc_t256
 
typedef etl::crc32_jamcrc_t< 16Ucrc32_jamcrc_t16
 
typedef etl::crc32_jamcrc_t< 4Ucrc32_jamcrc_t4
 
typedef crc32_jamcrc_t256 crc32_jamcrc
 
typedef etl::crc32_mpeg2_t< 256Ucrc32_mpeg2_t256
 
typedef etl::crc32_mpeg2_t< 16Ucrc32_mpeg2_t16
 
typedef etl::crc32_mpeg2_t< 4Ucrc32_mpeg2_t4
 
typedef crc32_mpeg2_t256 crc32_mpeg2
 
typedef etl::crc32_posix_t< 256Ucrc32_posix_t256
 
typedef etl::crc32_posix_t< 16Ucrc32_posix_t16
 
typedef etl::crc32_posix_t< 4Ucrc32_posix_t4
 
typedef crc32_posix_t256 crc32_posix
 
typedef etl::crc32_q_t< 256Ucrc32_q_t256
 
typedef etl::crc32_q_t< 16Ucrc32_q_t16
 
typedef etl::crc32_q_t< 4Ucrc32_q_t4
 
typedef crc32_q_t256 crc32_q
 
typedef etl::crc32_xfer_t< 256Ucrc32_xfer_t256
 
typedef etl::crc32_xfer_t< 16Ucrc32_xfer_t16
 
typedef etl::crc32_xfer_t< 4Ucrc32_xfer_t4
 
typedef crc32_xfer_t256 crc32_xfer
 
typedef etl::crc64_ecma_t< 256Ucrc64_ecma_t256
 
typedef etl::crc64_ecma_t< 16Ucrc64_ecma_t16
 
typedef etl::crc64_ecma_t< 4Ucrc64_ecma_t4
 
typedef crc64_ecma_t256 crc64_ecma
 
typedef crc8_ccitt_t< 256Ucrc8_ccitt_t256
 
typedef crc8_ccitt_t< 16Ucrc8_ccitt_t16
 
typedef crc8_ccitt_t< 4Ucrc8_ccitt_t4
 
typedef crc8_ccitt_t256 crc8_ccitt
 
typedef etl::crc8_cdma2000_t< 256Ucrc8_cdma2000_t256
 
typedef etl::crc8_cdma2000_t< 16Ucrc8_cdma2000_t16
 
typedef etl::crc8_cdma2000_t< 4Ucrc8_cdma2000_t4
 
typedef crc8_cdma2000_t256 crc8_cdma2000
 
typedef etl::crc8_darc_t< 256Ucrc8_darc_t256
 
typedef etl::crc8_darc_t< 16Ucrc8_darc_t16
 
typedef etl::crc8_darc_t< 4Ucrc8_darc_t4
 
typedef crc8_darc_t256 crc8_darc
 
typedef etl::crc8_dvbs2_t< 256Ucrc8_dvbs2_t256
 
typedef etl::crc8_dvbs2_t< 16Ucrc8_dvbs2_t16
 
typedef etl::crc8_dvbs2_t< 4Ucrc8_dvbs2_t4
 
typedef crc8_dvbs2_t256 crc8_dvbs2
 
typedef etl::crc8_ebu_t< 256Ucrc8_ebu_t256
 
typedef etl::crc8_ebu_t< 16Ucrc8_ebu_t16
 
typedef etl::crc8_ebu_t< 4Ucrc8_ebu_t4
 
typedef crc8_ebu_t256 crc8_ebu
 
typedef etl::crc8_icode_t< 256Ucrc8_icode_t256
 
typedef etl::crc8_icode_t< 16Ucrc8_icode_t16
 
typedef etl::crc8_icode_t< 4Ucrc8_icode_t4
 
typedef crc8_icode_t256 crc8_icode
 
typedef etl::crc8_itu_t< 256Ucrc8_itu_t256
 
typedef etl::crc8_itu_t< 16Ucrc8_itu_t16
 
typedef etl::crc8_itu_t< 4Ucrc8_itu_t4
 
typedef crc8_itu_t256 crc8_itu
 
typedef etl::crc8_j1850_t< 256Ucrc8_j1850_t256
 
typedef etl::crc8_j1850_t< 16Ucrc8_j1850_t16
 
typedef etl::crc8_j1850_t< 4Ucrc8_j1850_t4
 
typedef crc8_j1850_t256 crc8_j1850
 
typedef etl::crc8_j1850_zero_t< 256Ucrc8_j1850_zero_t256
 
typedef etl::crc8_j1850_zero_t< 16Ucrc8_j1850_zero_t16
 
typedef etl::crc8_j1850_zero_t< 4Ucrc8_j1850_zero_t4
 
typedef crc8_j1850_zero_t256 crc8_j1850_zero
 
typedef etl::crc8_maxim_t< 256Ucrc8_maxim_t256
 
typedef etl::crc8_maxim_t< 16Ucrc8_maxim_t16
 
typedef etl::crc8_maxim_t< 4Ucrc8_maxim_t4
 
typedef crc8_maxim_t256 crc8_maxim
 
typedef etl::crc8_rohc_t< 256Ucrc8_rohc_t256
 
typedef etl::crc8_rohc_t< 16Ucrc8_rohc_t16
 
typedef etl::crc8_rohc_t< 4Ucrc8_rohc_t4
 
typedef crc8_rohc_t256 crc8_rohc
 
typedef etl::crc8_wcdma_t< 256Ucrc8_wcdma_t256
 
typedef etl::crc8_wcdma_t< 16Ucrc8_wcdma_t16
 
typedef etl::crc8_wcdma_t< 4Ucrc8_wcdma_t4
 
typedef crc8_wcdma_t256 crc8_wcdma
 
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
 
using mutex = std::mutex
 This mutex class is implemented using std::mutex.
 
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< charistring
 
typedef etl::basic_string_stream< etl::format_spec, etl::istring, etl::string_viewstring_stream
 
typedef etl::basic_string_view< charstring_view
 
typedef etl::basic_string_view< wchar_twstring_view
 
typedef etl::basic_string_view< char8_t > u8string_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::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::iu8stringu8format_spec
 
typedef etl::ibasic_string< char8_t > iu8string
 
typedef etl::basic_string_stream< etl::u8format_spec, etl::iu8string, etl::u8string_viewu8string_stream
 
typedef unaligned_type< char, etl::endian::little > le_char_t
 
typedef unaligned_type< signed char, etl::endian::little > le_schar_t
 
typedef unaligned_type< unsigned char, etl::endian::little > le_uchar_t
 
typedef unaligned_type< short, etl::endian::little > le_short_t
 
typedef unaligned_type< unsigned short, etl::endian::little > le_ushort_t
 
typedef unaligned_type< int, etl::endian::little > le_int_t
 
typedef unaligned_type< unsigned int, etl::endian::little > le_uint_t
 
typedef unaligned_type< long, etl::endian::little > le_long_t
 
typedef unaligned_type< unsigned long, etl::endian::little > le_ulong_t
 
typedef unaligned_type< long long, etl::endian::little > le_long_long_t
 
typedef unaligned_type< unsigned long long, etl::endian::little > le_ulong_long_t
 
typedef unaligned_type< int16_t, etl::endian::little > le_int16_t
 
typedef unaligned_type< uint16_t, etl::endian::little > le_uint16_t
 
typedef unaligned_type< int32_t, etl::endian::little > le_int32_t
 
typedef unaligned_type< uint32_t, etl::endian::little > le_uint32_t
 
typedef unaligned_type< int64_t, etl::endian::little > le_int64_t
 
typedef unaligned_type< uint64_t, etl::endian::little > le_uint64_t
 
typedef unaligned_type< float, etl::endian::little > le_float_t
 
typedef unaligned_type< double, etl::endian::little > le_double_t
 
typedef unaligned_type< long double, etl::endian::little > le_long_double_t
 
typedef unaligned_type< char, etl::endian::big > be_char_t
 
typedef unaligned_type< signed char, etl::endian::big > be_schar_t
 
typedef unaligned_type< unsigned char, etl::endian::big > be_uchar_t
 
typedef unaligned_type< short, etl::endian::big > be_short_t
 
typedef unaligned_type< unsigned short, etl::endian::big > be_ushort_t
 
typedef unaligned_type< int, etl::endian::big > be_int_t
 
typedef unaligned_type< unsigned int, etl::endian::big > be_uint_t
 
typedef unaligned_type< long, etl::endian::big > be_long_t
 
typedef unaligned_type< unsigned long, etl::endian::big > be_ulong_t
 
typedef unaligned_type< long long, etl::endian::big > be_long_long_t
 
typedef unaligned_type< unsigned long long, etl::endian::big > be_ulong_long_t
 
typedef unaligned_type< int16_t, etl::endian::big > be_int16_t
 
typedef unaligned_type< uint16_t, etl::endian::big > be_uint16_t
 
typedef unaligned_type< int32_t, etl::endian::big > be_int32_t
 
typedef unaligned_type< uint32_t, etl::endian::big > be_uint32_t
 
typedef unaligned_type< int64_t, etl::endian::big > be_int64_t
 
typedef unaligned_type< uint64_t, etl::endian::big > be_uint64_t
 
typedef unaligned_type< float, etl::endian::big > be_float_t
 
typedef unaligned_type< double, etl::endian::big > be_double_t
 
typedef unaligned_type< long double, etl::endian::big > be_long_double_t
 
typedef be_char_t net_char_t
 
typedef be_schar_t net_schar_t
 
typedef be_uchar_t net_uchar_t
 
typedef be_short_t net_short_t
 
typedef be_ushort_t net_ushort_t
 
typedef be_int_t net_int_t
 
typedef be_uint_t net_uint_t
 
typedef be_long_t net_long_t
 
typedef be_ulong_t net_ulong_t
 
typedef be_long_long_t net_long_long_t
 
typedef be_ulong_long_t net_ulong_long_t
 
typedef be_int16_t net_int16_t
 
typedef be_uint16_t net_uint16_t
 
typedef be_int32_t net_int32_t
 
typedef be_uint32_t net_uint32_t
 
typedef be_int64_t net_int64_t
 
typedef be_uint64_t net_uint64_t
 
typedef be_float_t net_float_t
 
typedef be_double_t net_double_t
 
typedef be_long_double_t net_long_double_t
 
typedef unaligned_type_ext< char, etl::endian::little > le_char_ext_t
 
typedef unaligned_type_ext< signed char, etl::endian::little > le_schar_ext_t
 
typedef unaligned_type_ext< unsigned char, etl::endian::little > le_uchar_ext_t
 
typedef unaligned_type_ext< short, etl::endian::little > le_short_ext_t
 
typedef unaligned_type_ext< unsigned short, etl::endian::little > le_ushort_ext_t
 
typedef unaligned_type_ext< int, etl::endian::little > le_int_ext_t
 
typedef unaligned_type_ext< unsigned int, etl::endian::little > le_uint_ext_t
 
typedef unaligned_type_ext< long, etl::endian::little > le_long_ext_t
 
typedef unaligned_type_ext< unsigned long, etl::endian::little > le_ulong_ext_t
 
typedef unaligned_type_ext< long long, etl::endian::little > le_long_long_ext_t
 
typedef unaligned_type_ext< unsigned long long, etl::endian::little > le_ulong_long_ext_t
 
typedef unaligned_type_ext< int16_t, etl::endian::little > le_int16_ext_t
 
typedef unaligned_type_ext< uint16_t, etl::endian::little > le_uint16_ext_t
 
typedef unaligned_type_ext< int32_t, etl::endian::little > le_int32_ext_t
 
typedef unaligned_type_ext< uint32_t, etl::endian::little > le_uint32_ext_t
 
typedef unaligned_type_ext< int64_t, etl::endian::little > le_int64_ext_t
 
typedef unaligned_type_ext< uint64_t, etl::endian::little > le_uint64_ext_t
 
typedef unaligned_type_ext< float, etl::endian::little > le_float_ext_t
 
typedef unaligned_type_ext< double, etl::endian::little > le_double_ext_t
 
typedef unaligned_type_ext< long double, etl::endian::little > le_long_double_ext_t
 
typedef unaligned_type_ext< char, etl::endian::big > be_char_ext_t
 
typedef unaligned_type_ext< signed char, etl::endian::big > be_schar_ext_t
 
typedef unaligned_type_ext< unsigned char, etl::endian::big > be_uchar_ext_t
 
typedef unaligned_type_ext< short, etl::endian::big > be_short_ext_t
 
typedef unaligned_type_ext< unsigned short, etl::endian::big > be_ushort_ext_t
 
typedef unaligned_type_ext< int, etl::endian::big > be_int_ext_t
 
typedef unaligned_type_ext< unsigned int, etl::endian::big > be_uint_ext_t
 
typedef unaligned_type_ext< long, etl::endian::big > be_long_ext_t
 
typedef unaligned_type_ext< unsigned long, etl::endian::big > be_ulong_ext_t
 
typedef unaligned_type_ext< long long, etl::endian::big > be_long_long_ext_t
 
typedef unaligned_type_ext< unsigned long long, etl::endian::big > be_ulong_long_ext_t
 
typedef unaligned_type_ext< int16_t, etl::endian::big > be_int16_ext_t
 
typedef unaligned_type_ext< uint16_t, etl::endian::big > be_uint16_ext_t
 
typedef unaligned_type_ext< int32_t, etl::endian::big > be_int32_ext_t
 
typedef unaligned_type_ext< uint32_t, etl::endian::big > be_uint32_ext_t
 
typedef unaligned_type_ext< int64_t, etl::endian::big > be_int64_ext_t
 
typedef unaligned_type_ext< uint64_t, etl::endian::big > be_uint64_ext_t
 
typedef unaligned_type_ext< float, etl::endian::big > be_float_ext_t
 
typedef unaligned_type_ext< double, etl::endian::big > be_double_ext_t
 
typedef unaligned_type_ext< long double, etl::endian::big > be_long_double_ext_t
 
typedef be_char_ext_t net_char_ext_t
 
typedef be_schar_ext_t net_schar_ext_t
 
typedef be_uchar_ext_t net_uchar_ext_t
 
typedef be_short_ext_t net_short_ext_t
 
typedef be_ushort_ext_t net_ushort_ext_t
 
typedef be_int_ext_t net_int_ext_t
 
typedef be_uint_ext_t net_uint_ext_t
 
typedef be_long_ext_t net_long_ext_t
 
typedef be_ulong_ext_t net_ulong_ext_t
 
typedef be_long_long_ext_t net_long_long_ext_t
 
typedef be_ulong_long_ext_t net_ulong_long_ext_t
 
typedef be_int16_ext_t net_int16_ext_t
 
typedef be_uint16_ext_t net_uint16_ext_t
 
typedef be_int32_ext_t net_int32_ext_t
 
typedef be_uint32_ext_t net_uint32_ext_t
 
typedef be_int64_ext_t net_int64_ext_t
 
typedef be_uint64_ext_t net_uint64_ext_t
 
typedef be_float_ext_t net_float_ext_t
 
typedef be_double_ext_t net_double_ext_t
 
typedef be_long_double_ext_t net_long_double_ext_t
 
typedef etl::basic_format_spec< etl::iwstringwformat_spec
 
typedef ibasic_string< wchar_tiwstring
 
typedef etl::basic_string_stream< etl::wformat_spec, etl::iwstring, etl::wstring_viewwstring_stream
 

Enumerations

enum  binary_constant {
  b00000000 = 0U , b00000001 = 1U , b00000010 = 2U , b00000011 = 3U ,
  b00000100 = 4U , b00000101 = 5U , b00000110 = 6U , b00000111 = 7U ,
  b00001000 = 8U , b00001001 = 9U , b00001010 = 10U , b00001011 = 11U ,
  b00001100 = 12U , b00001101 = 13U , b00001110 = 14U , b00001111 = 15U ,
  b00010000 = 16U , b00010001 = 17U , b00010010 = 18U , b00010011 = 19U ,
  b00010100 = 20U , b00010101 = 21U , b00010110 = 22U , b00010111 = 23U ,
  b00011000 = 24U , b00011001 = 25U , b00011010 = 26U , b00011011 = 27U ,
  b00011100 = 28U , b00011101 = 29U , b00011110 = 30U , b00011111 = 31U ,
  b00100000 = 32U , b00100001 = 33U , b00100010 = 34U , b00100011 = 35U ,
  b00100100 = 36U , b00100101 = 37U , b00100110 = 38U , b00100111 = 39U ,
  b00101000 = 40U , b00101001 = 41U , b00101010 = 42U , b00101011 = 43U ,
  b00101100 = 44U , b00101101 = 45U , b00101110 = 46U , b00101111 = 47U ,
  b00110000 = 48U , b00110001 = 49U , b00110010 = 50U , b00110011 = 51U ,
  b00110100 = 52U , b00110101 = 53U , b00110110 = 54U , b00110111 = 55U ,
  b00111000 = 56U , b00111001 = 57U , b00111010 = 58U , b00111011 = 59U ,
  b00111100 = 60U , b00111101 = 61U , b00111110 = 62U , b00111111 = 63U ,
  b01000000 = 64U , b01000001 = 65U , b01000010 = 66U , b01000011 = 67U ,
  b01000100 = 68U , b01000101 = 69U , b01000110 = 70U , b01000111 = 71U ,
  b01001000 = 72U , b01001001 = 73U , b01001010 = 74U , b01001011 = 75U ,
  b01001100 = 76U , b01001101 = 77U , b01001110 = 78U , b01001111 = 79U ,
  b01010000 = 80U , b01010001 = 81U , b01010010 = 82U , b01010011 = 83U ,
  b01010100 = 84U , b01010101 = 85U , b01010110 = 86U , b01010111 = 87U ,
  b01011000 = 88U , b01011001 = 89U , b01011010 = 90U , b01011011 = 91U ,
  b01011100 = 92U , b01011101 = 93U , b01011110 = 94U , b01011111 = 95U ,
  b01100000 = 96U , b01100001 = 97U , b01100010 = 98U , b01100011 = 99U ,
  b01100100 = 100U , b01100101 = 101U , b01100110 = 102U , b01100111 = 103U ,
  b01101000 = 104U , b01101001 = 105U , b01101010 = 106U , b01101011 = 107U ,
  b01101100 = 108U , b01101101 = 109U , b01101110 = 110U , b01101111 = 111U ,
  b01110000 = 112U , b01110001 = 113U , b01110010 = 114U , b01110011 = 115U ,
  b01110100 = 116U , b01110101 = 117U , b01110110 = 118U , b01110111 = 119U ,
  b01111000 = 120U , b01111001 = 121U , b01111010 = 122U , b01111011 = 123U ,
  b01111100 = 124U , b01111101 = 125U , b01111110 = 126U , b01111111 = 127U ,
  b10000000 = 128U , b10000001 = 129U , b10000010 = 130U , b10000011 = 131U ,
  b10000100 = 132U , b10000101 = 133U , b10000110 = 134U , b10000111 = 135U ,
  b10001000 = 136U , b10001001 = 137U , b10001010 = 138U , b10001011 = 139U ,
  b10001100 = 140U , b10001101 = 141U , b10001110 = 142U , b10001111 = 143U ,
  b10010000 = 144U , b10010001 = 145U , b10010010 = 146U , b10010011 = 147U ,
  b10010100 = 148U , b10010101 = 149U , b10010110 = 150U , b10010111 = 151U ,
  b10011000 = 152U , b10011001 = 153U , b10011010 = 154U , b10011011 = 155U ,
  b10011100 = 156U , b10011101 = 157U , b10011110 = 158U , b10011111 = 159U ,
  b10100000 = 160U , b10100001 = 161U , b10100010 = 162U , b10100011 = 163U ,
  b10100100 = 164U , b10100101 = 165U , b10100110 = 166U , b10100111 = 167U ,
  b10101000 = 168U , b10101001 = 169U , b10101010 = 170U , b10101011 = 171U ,
  b10101100 = 172U , b10101101 = 173U , b10101110 = 174U , b10101111 = 175U ,
  b10110000 = 176U , b10110001 = 177U , b10110010 = 178U , b10110011 = 179U ,
  b10110100 = 180U , b10110101 = 181U , b10110110 = 182U , b10110111 = 183U ,
  b10111000 = 184U , b10111001 = 185U , b10111010 = 186U , b10111011 = 187U ,
  b10111100 = 188U , b10111101 = 189U , b10111110 = 190U , b10111111 = 191U ,
  b11000000 = 192U , b11000001 = 193U , b11000010 = 194U , b11000011 = 195U ,
  b11000100 = 196U , b11000101 = 197U , b11000110 = 198U , b11000111 = 199U ,
  b11001000 = 200U , b11001001 = 201U , b11001010 = 202U , b11001011 = 203U ,
  b11001100 = 204U , b11001101 = 205U , b11001110 = 206U , b11001111 = 207U ,
  b11010000 = 208U , b11010001 = 209U , b11010010 = 210U , b11010011 = 211U ,
  b11010100 = 212U , b11010101 = 213U , b11010110 = 214U , b11010111 = 215U ,
  b11011000 = 216U , b11011001 = 217U , b11011010 = 218U , b11011011 = 219U ,
  b11011100 = 220U , b11011101 = 221U , b11011110 = 222U , b11011111 = 223U ,
  b11100000 = 224U , b11100001 = 225U , b11100010 = 226U , b11100011 = 227U ,
  b11100100 = 228U , b11100101 = 229U , b11100110 = 230U , b11100111 = 231U ,
  b11101000 = 232U , b11101001 = 233U , b11101010 = 234U , b11101011 = 235U ,
  b11101100 = 236U , b11101101 = 237U , b11101110 = 238U , b11101111 = 239U ,
  b11110000 = 240U , b11110001 = 241U , b11110010 = 242U , b11110011 = 243U ,
  b11110100 = 244U , b11110101 = 245U , b11110110 = 246U , b11110111 = 247U ,
  b11111000 = 248U , b11111001 = 249U , b11111010 = 250U , b11111011 = 251U ,
  b11111100 = 252U , b11111101 = 253U , b11111110 = 254U , b11111111 = 255U
}
 
enum  bit_constant {
  b0 = 0x1UL , b1 = 0x2UL , b2 = 0x4UL , b3 = 0x8UL ,
  b4 = 0x10UL , b5 = 0x20UL , b6 = 0x40UL , b7 = 0x80UL ,
  b8 = 0x100UL , b9 = 0x200UL , b10 = 0x400UL , b11 = 0x800UL ,
  b12 = 0x1000UL , b13 = 0x2000UL , b14 = 0x4000UL , b15 = 0x8000UL ,
  b16 = 0x10000UL , b17 = 0x20000UL , b18 = 0x40000UL , b19 = 0x80000UL ,
  b20 = 0x100000UL , b21 = 0x200000UL , b22 = 0x400000UL , b23 = 0x800000UL ,
  b24 = 0x1000000UL , b25 = 0x2000000UL , b26 = 0x4000000UL , b27 = 0x8000000UL ,
  b28 = 0x10000000UL , b29 = 0x20000000UL , b30 = 0x40000000UL , b31 = 0x80000000UL
}
 
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_NODISCARD ETL_CONSTEXPR etl::enable_if< etl::is_signed< T >::value, T >::type absolute (T value) ETL_NOEXCEPT
 
template<typename T >
ETL_NODISCARD ETL_CONSTEXPR etl::enable_if< etl::is_unsigned< T >::value, T >::type absolute (T value) ETL_NOEXCEPT
 
template<typename T , typename TReturn >
ETL_NODISCARD ETL_CONSTEXPR etl::enable_if< etl::is_signed< T >::value, TReturn >::type absolute_unsigned (T value) ETL_NOEXCEPT
 
template<typename T >
ETL_NODISCARD ETL_CONSTEXPR etl::enable_if< etl::is_unsigned< T >::value, T >::type absolute_unsigned (T value) ETL_NOEXCEPT
 
template<typename TIterator >
ETL_CONSTEXPR20 void shell_sort (TIterator first, TIterator last)
 
template<typename TIterator , typename TCompare >
ETL_CONSTEXPR20 void shell_sort (TIterator first, TIterator last, TCompare compare)
 
template<typename TIterator >
ETL_CONSTEXPR14 void insertion_sort (TIterator first, TIterator last)
 
template<typename TIterator , typename TCompare >
ETL_CONSTEXPR14 void insertion_sort (TIterator first, TIterator last, TCompare compare)
 
template<typename TIterator1 , typename TIterator2 >
ETL_CONSTEXPR20 void iter_swap (TIterator1 a, TIterator2 b)
 
template<typename TIterator1 , typename TIterator2 >
ETL_CONSTEXPR20 TIterator2 swap_ranges (TIterator1 first1, TIterator1 last1, TIterator2 first2)
 
template<typename TIterator , typename TFunction >
ETL_CONSTEXPR14 void generate (TIterator db, TIterator de, TFunction funct)
 
template<typename TIterator1 , typename TIterator2 >
ETL_CONSTEXPR14 TIterator2 copy (TIterator1 sb, TIterator1 se, TIterator2 db)
 
template<typename TIterator1 , typename TIterator2 >
ETL_CONSTEXPR14 TIterator2 reverse_copy (TIterator1 sb, TIterator1 se, TIterator2 db)
 
template<typename TIterator1 , typename TSize , typename TIterator2 >
ETL_CONSTEXPR14 TIterator2 copy_n (TIterator1 sb, TSize count, TIterator2 db)
 
template<typename TIterator1 , typename TIterator2 >
ETL_CONSTEXPR14 TIterator2 copy_backward (TIterator1 sb, TIterator1 se, TIterator2 de)
 
template<typename TIterator1 , typename TIterator2 >
ETL_CONSTEXPR14 TIterator2 move (TIterator1 sb, TIterator1 se, TIterator2 db)
 
template<typename TIterator1 , typename TIterator2 >
ETL_CONSTEXPR14 TIterator2 move_backward (TIterator1 sb, TIterator1 se, TIterator2 de)
 
template<typename TIterator >
ETL_CONSTEXPR14 etl::enable_if< etl::is_pointer< TIterator >::value, void >::type reverse (TIterator b, TIterator e)
 
template<typename TIterator >
ETL_CONSTEXPR14 etl::enable_if<!etl::is_pointer< TIterator >::value, void >::type reverse (TIterator b, TIterator e)
 
template<typename TIterator , typename TValue , typename TCompare >
ETL_NODISCARD ETL_CONSTEXPR14 TIterator lower_bound (TIterator first, TIterator last, const TValue &value, TCompare compare)
 
template<typename TIterator , typename TValue >
ETL_NODISCARD ETL_CONSTEXPR14 TIterator lower_bound (TIterator first, TIterator last, const TValue &value)
 
template<typename TIterator , typename TValue , typename TCompare >
ETL_NODISCARD ETL_CONSTEXPR14 TIterator upper_bound (TIterator first, TIterator last, const TValue &value, TCompare compare)
 
template<typename TIterator , typename TValue >
ETL_NODISCARD ETL_CONSTEXPR14 TIterator upper_bound (TIterator first, TIterator last, const TValue &value)
 
template<typename TIterator , typename TValue , typename TCompare >
ETL_NODISCARD ETL_CONSTEXPR14 ETL_OR_STD::pair< TIterator, TIteratorequal_range (TIterator first, TIterator last, const TValue &value, TCompare compare)
 
template<typename TIterator , typename TValue >
ETL_NODISCARD ETL_OR_STD::pair< TIterator, TIteratorequal_range (TIterator first, TIterator last, const TValue &value)
 
template<typename TIterator , typename T , typename Compare >
ETL_NODISCARD bool binary_search (TIterator first, TIterator last, const T &value, Compare compare)
 
template<typename TIterator , typename T >
ETL_NODISCARD bool binary_search (TIterator first, TIterator last, const T &value)
 
template<typename TIterator , typename TUnaryPredicate >
ETL_NODISCARD ETL_CONSTEXPR14 TIterator find_if (TIterator first, TIterator last, TUnaryPredicate predicate)
 
template<typename TIterator , typename T >
ETL_NODISCARD ETL_CONSTEXPR14 TIterator find (TIterator first, TIterator last, const T &value)
 
template<typename TIterator , typename TValue >
ETL_CONSTEXPR14 void fill (TIterator first, TIterator last, const TValue &value)
 
template<typename TIterator , typename TSize , typename TValue >
ETL_CONSTEXPR14 TIterator fill_n (TIterator first, TSize count, const TValue &value)
 
template<typename TIterator , typename T >
ETL_NODISCARD ETL_CONSTEXPR14 etl::iterator_traits< TIterator >::difference_type count (TIterator first, TIterator last, const T &value)
 
template<typename TIterator , typename TUnaryPredicate >
ETL_NODISCARD ETL_CONSTEXPR14 etl::iterator_traits< TIterator >::difference_type count_if (TIterator first, TIterator last, TUnaryPredicate predicate)
 
template<typename TIterator1 , typename TIterator2 >
ETL_NODISCARD ETL_CONSTEXPR14 bool equal (TIterator1 first1, TIterator1 last1, TIterator2 first2)
 
template<typename TIterator1 , typename TIterator2 , typename TPredicate >
ETL_NODISCARD ETL_CONSTEXPR14 bool equal (TIterator1 first1, TIterator1 last1, TIterator2 first2, TPredicate predicate)
 
template<typename TIterator1 , typename TIterator2 >
ETL_NODISCARD ETL_CONSTEXPR14 bool equal (TIterator1 first1, TIterator1 last1, TIterator2 first2, TIterator2 last2)
 
template<typename TIterator1 , typename TIterator2 , typename TPredicate >
ETL_NODISCARD ETL_CONSTEXPR14 bool equal (TIterator1 first1, TIterator1 last1, TIterator2 first2, TIterator2 last2, TPredicate predicate)
 
template<typename TIterator1 , typename TIterator2 , typename TCompare >
ETL_NODISCARD ETL_CONSTEXPR14 bool lexicographical_compare (TIterator1 first1, TIterator1 last1, TIterator2 first2, TIterator2 last2, TCompare compare)
 
template<typename TIterator1 , typename TIterator2 >
ETL_NODISCARD ETL_CONSTEXPR14 bool lexicographical_compare (TIterator1 first1, TIterator1 last1, TIterator2 first2, TIterator2 last2)
 
template<typename T , typename TCompare >
ETL_NODISCARD ETL_CONSTEXPR const Tmin (const T &a, const T &b, TCompare compare)
 
template<typename T >
ETL_NODISCARD ETL_CONSTEXPR const Tmin (const T &a, const T &b)
 
template<typename T , typename TCompare >
ETL_NODISCARD ETL_CONSTEXPR const Tmax (const T &a, const T &b, TCompare compare)
 
template<typename T >
ETL_NODISCARD ETL_CONSTEXPR const Tmax (const T &a, const T &b)
 
template<typename TIterator , typename TUnaryOperation >
ETL_CONSTEXPR14 TUnaryOperation for_each (TIterator first, TIterator last, TUnaryOperation unary_operation)
 
template<typename TIteratorIn , typename TIteratorOut , typename TUnaryOperation >
ETL_CONSTEXPR14 TIteratorOut transform (TIteratorIn first1, TIteratorIn last1, TIteratorOut d_first, TUnaryOperation unary_operation)
 
template<typename TIteratorIn1 , typename TIteratorIn2 , typename TIteratorOut , typename TBinaryOperation >
ETL_CONSTEXPR14 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 >
ETL_NODISCARD bool is_heap (TIterator first, TIterator last)
 
template<typename TIterator , typename TCompare >
ETL_NODISCARD bool is_heap (TIterator first, TIterator last, TCompare compare)
 
template<typename TIterator >
void sort_heap (TIterator first, TIterator last)
 
template<typename TIterator , typename TCompare >
void sort_heap (TIterator first, TIterator last, TCompare compare)
 
template<typename TIterator1 , typename TIterator2 , typename TCompare >
ETL_NODISCARD ETL_CONSTEXPR14 TIterator1 search (TIterator1 first, TIterator1 last, TIterator2 search_first, TIterator2 search_last, TCompare compare)
 
template<typename TIterator1 , typename TIterator2 >
ETL_NODISCARD ETL_CONSTEXPR14 TIterator1 search (TIterator1 first, TIterator1 last, TIterator2 search_first, TIterator2 search_last)
 
template<typename TIterator >
ETL_CONSTEXPR14 TIterator rotate (TIterator first, TIterator middle, TIterator last)
 
template<typename TIterator1 , typename TIterator2 , typename TPredicate >
ETL_NODISCARD ETL_CONSTEXPR14 TIterator1 find_end (TIterator1 b, TIterator1 e, TIterator2 sb, TIterator2 se, TPredicate predicate)
 
template<typename TIterator1 , typename TIterator2 >
ETL_NODISCARD ETL_CONSTEXPR14 TIterator1 find_end (TIterator1 b, TIterator1 e, TIterator2 sb, TIterator2 se)
 
template<typename TIterator , typename TCompare >
ETL_NODISCARD ETL_CONSTEXPR14 TIterator min_element (TIterator begin, TIterator end, TCompare compare)
 
template<typename TIterator >
ETL_NODISCARD ETL_CONSTEXPR14 TIterator min_element (TIterator begin, TIterator end)
 
template<typename TIterator , typename TCompare >
ETL_NODISCARD ETL_CONSTEXPR14 TIterator max_element (TIterator begin, TIterator end, TCompare compare)
 
template<typename TIterator >
ETL_NODISCARD ETL_CONSTEXPR14 TIterator max_element (TIterator begin, TIterator end)
 
template<typename TIterator , typename TCompare >
ETL_NODISCARD ETL_CONSTEXPR14 ETL_OR_STD::pair< TIterator, TIteratorminmax_element (TIterator begin, TIterator end, TCompare compare)
 
template<typename TIterator >
ETL_NODISCARD ETL_CONSTEXPR14 ETL_OR_STD::pair< TIterator, TIteratorminmax_element (TIterator begin, TIterator end)
 
template<typename T >
ETL_NODISCARD ETL_CONSTEXPR14 ETL_OR_STD::pair< const T &, const T & > minmax (const T &a, const T &b)
 
template<typename T , typename TCompare >
ETL_NODISCARD ETL_CONSTEXPR14 ETL_OR_STD::pair< const T &, const T & > minmax (const T &a, const T &b, TCompare compare)
 
template<typename TIterator >
ETL_NODISCARD ETL_CONSTEXPR14 TIterator is_sorted_until (TIterator begin, TIterator end)
 
template<typename TIterator , typename TCompare >
ETL_NODISCARD ETL_CONSTEXPR14 TIterator is_sorted_until (TIterator begin, TIterator end, TCompare compare)
 
template<typename TIterator >
ETL_NODISCARD ETL_CONSTEXPR14 bool is_sorted (TIterator begin, TIterator end)
 
template<typename TIterator , typename TCompare >
ETL_NODISCARD ETL_CONSTEXPR14 bool is_sorted (TIterator begin, TIterator end, TCompare compare)
 
template<typename TIterator , typename TUnaryPredicate >
ETL_NODISCARD ETL_CONSTEXPR14 TIterator find_if_not (TIterator begin, TIterator end, TUnaryPredicate predicate)
 
template<typename TIterator1 , typename TIterator2 >
ETL_NODISCARD ETL_CONSTEXPR14 bool is_permutation (TIterator1 begin1, TIterator1 end1, TIterator2 begin2)
 
template<typename TIterator1 , typename TIterator2 , typename TBinaryPredicate >
ETL_NODISCARD ETL_CONSTEXPR14 bool is_permutation (TIterator1 begin1, TIterator1 end1, TIterator2 begin2, TBinaryPredicate predicate)
 
template<typename TIterator1 , typename TIterator2 >
ETL_NODISCARD ETL_CONSTEXPR14 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 ETL_CONSTEXPR14 bool is_partitioned (TIterator begin, TIterator end, TUnaryPredicate predicate)
 
template<typename TIterator , typename TUnaryPredicate >
ETL_NODISCARD ETL_CONSTEXPR14 TIterator partition_point (TIterator begin, TIterator end, TUnaryPredicate predicate)
 
template<typename TSource , typename TDestinationTrue , typename TDestinationFalse , typename TUnaryPredicate >
ETL_CONSTEXPR14 ETL_OR_STD::pair< TDestinationTrue, TDestinationFalsepartition_copy (TSource begin, TSource end, TDestinationTrue destination_true, TDestinationFalse destination_false, TUnaryPredicate predicate)
 
template<typename TIterator , typename TOutputIterator , typename TUnaryPredicate >
ETL_CONSTEXPR14 TOutputIterator copy_if (TIterator begin, TIterator end, TOutputIterator out, TUnaryPredicate predicate)
 
template<typename TIterator , typename TUnaryPredicate >
ETL_NODISCARD ETL_CONSTEXPR14 bool all_of (TIterator begin, TIterator end, TUnaryPredicate predicate)
 
template<typename TIterator , typename TUnaryPredicate >
ETL_NODISCARD ETL_CONSTEXPR14 bool any_of (TIterator begin, TIterator end, TUnaryPredicate predicate)
 
template<typename TIterator , typename TUnaryPredicate >
ETL_NODISCARD ETL_CONSTEXPR14 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 TIterator , typename T >
ETL_CONSTEXPR14 T accumulate (TIterator first, TIterator last, T sum)
 
template<typename TIterator , typename T , typename TBinaryOperation >
ETL_CONSTEXPR14 T accumulate (TIterator first, TIterator last, T sum, TBinaryOperation operation)
 
template<typename T , typename TCompare >
ETL_CONSTEXPR T clamp (const T &value, const T &low, const T &high, TCompare compare)
 
template<typename T >
ETL_CONSTEXPR T clamp (const T &value, const T &low, const T &high)
 
template<typename T , T Low, T High, typename TCompare >
ETL_CONSTEXPR T clamp (const T &value, TCompare compare)
 
template<typename T , T Low, T High>
ETL_CONSTEXPR T clamp (const T &value)
 
template<typename TIterator , typename T >
ETL_CONSTEXPR14 TIterator remove (TIterator first, TIterator last, const T &value)
 
template<typename TIterator , typename TUnaryPredicate >
ETL_CONSTEXPR14 TIterator remove_if (TIterator first, TIterator last, TUnaryPredicate predicate)
 
template<typename TInputIterator , typename TOutputIterator >
ETL_CONSTEXPR14 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_CONSTEXPR14 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 >
ETL_CONSTEXPR14 TOutputIterator copy_n_s (TInputIterator i_begin, TSize n, TOutputIterator o_begin, TOutputIterator o_end)
 
template<typename TInputIterator , typename TSize1 , typename TOutputIterator , typename TSize2 >
ETL_CONSTEXPR14 TOutputIterator copy_n_s (TInputIterator i_begin, TSize1 n1, TOutputIterator o_begin, TSize2 n2)
 
template<typename TInputIterator , typename TOutputIterator , typename TUnaryPredicate >
ETL_CONSTEXPR14 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 >
ETL_CONSTEXPR14 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 ETL_CONSTEXPR14 TIterator binary_find (TIterator begin, TIterator end, const TValue &value)
 
template<typename TIterator , typename TValue , typename TBinaryPredicate , typename TBinaryEquality >
ETL_NODISCARD ETL_CONSTEXPR14 TIterator binary_find (TIterator begin, TIterator end, const TValue &value, TBinaryPredicate predicate, TBinaryEquality equality)
 
template<typename TIterator , typename TUnaryFunction , typename TUnaryPredicate >
ETL_CONSTEXPR14 TUnaryFunction for_each_if (TIterator begin, const TIterator end, TUnaryFunction function, TUnaryPredicate predicate)
 
template<typename TIterator , typename TSize , typename TUnaryFunction >
ETL_CONSTEXPR14 TIterator for_each_n (TIterator begin, TSize n, TUnaryFunction function)
 
template<typename TIterator , typename TSize , typename TUnaryFunction , typename TUnaryPredicate >
ETL_CONSTEXPR14 TIterator for_each_n_if (TIterator begin, TSize n, TUnaryFunction function, TUnaryPredicate predicate)
 
template<typename TInputIterator , typename TOutputIterator , typename TUnaryFunction >
ETL_CONSTEXPR14 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 >
ETL_CONSTEXPR14 void transform_n (TInputIterator i_begin, TSize n, TOutputIterator o_begin, TUnaryFunction function)
 
template<typename TInputIterator1 , typename TInputIterator2 , typename TSize , typename TOutputIterator , typename TBinaryFunction >
ETL_CONSTEXPR14 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 >
ETL_CONSTEXPR14 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 >
ETL_CONSTEXPR14 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 >
ETL_CONSTEXPR14 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 >
ETL_CONSTEXPR14 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_CONSTEXPR14 ETL_OR_STD::pair< TDestinationTrue, TDestinationFalsepartition_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_CONSTEXPR14 ETL_OR_STD::pair< TDestinationTrue, TDestinationFalsepartition_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 >
ETL_CONSTEXPR20 void selection_sort (TIterator first, TIterator last, TCompare compare)
 
template<typename TIterator >
ETL_CONSTEXPR20 void selection_sort (TIterator first, TIterator last)
 
template<typename TIterator , typename TCompare >
ETL_CONSTEXPR14 void heap_sort (TIterator first, TIterator last, TCompare compare)
 
template<typename TIterator >
ETL_CONSTEXPR14 void heap_sort (TIterator first, TIterator last)
 
template<typename TIterator , typename TPredicate >
ETL_CONSTEXPR14 etl::enable_if< etl::is_forward_iterator< TIterator >::value, TIterator >::type partition (TIterator first, TIterator last, TPredicate predicate)
 Returns the maximum value.
 
template<typename TIterator , typename TPredicate >
ETL_CONSTEXPR14 etl::enable_if< etl::is_bidirectional_iterator_concept< TIterator >::value, TIterator >::type partition (TIterator first, TIterator last, TPredicate predicate)
 
template<typename TIterator , typename TCompare >
etl::enable_if< etl::is_random_access_iterator_concept< TIterator >::value, void >::type nth_element (TIterator first, TIterator nth, TIterator last, TCompare compare)
 
template<typename TIterator >
etl::enable_if< etl::is_random_access_iterator_concept< TIterator >::value, void >::type nth_element (TIterator first, TIterator nth, TIterator last)
 
bool is_aligned (void *p, size_t required_alignment)
 Check that 'p' has 'required_alignment'.
 
template<size_t Alignment>
bool is_aligned (void *p)
 Check that 'p' has 'Alignment'.
 
template<typename T , const size_t SIZE>
void swap (etl::array< T, SIZE > &lhs, etl::array< T, SIZE > &rhs)
 Template deduction guides.
 
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>
Tget (array< T, MAXN > &a)
 
template<size_t I, typename T , size_t MAXN>
const Tget (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 , size_t NBITS, typename TValue >
ETL_CONSTEXPR14 TReturn fold_bits (TValue value)
 
template<typename TReturn , size_t NBITS, typename TValue >
ETL_CONSTEXPR14 TReturn sign_extend (TValue value)
 
template<typename TReturn , size_t NBITS, size_t SHIFT, typename TValue >
ETL_CONSTEXPR14 TReturn sign_extend (TValue value)
 
template<typename TReturn , typename TValue >
ETL_CONSTEXPR14 TReturn sign_extend (TValue value, size_t NBITS)
 
template<typename TReturn , typename TValue >
ETL_CONSTEXPR14 TReturn sign_extend (TValue value, size_t NBITS, size_t SHIFT)
 
template<typename TResult , typename TValue >
ETL_CONSTEXPR TResult binary_fill (TValue value)
 
template<typename TResult , typename TValue , TValue N>
ETL_CONSTEXPR TResult binary_fill ()
 
template<typename T >
ETL_CONSTEXPR T binary_merge (T first, T second, T mask)
 
template<typename T , T MASK>
ETL_CONSTEXPR T binary_merge (T first, T second)
 
template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_unsigned< T >::value &&(etl::integral_limits< T >::bits==16U), T >::type reverse_bits (T value)
 
template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_unsigned< T >::value &&(etl::integral_limits< T >::bits==32U), T >::type reverse_bits (T value)
 
template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_unsigned< T >::value &&(etl::integral_limits< T >::bits==64U), T >::type reverse_bits (T value)
 
template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_signed< T >::value, T >::type reverse_bits (T value)
 
template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_unsigned< T >::value &&(etl::integral_limits< T >::bits==16U), T >::type reverse_bytes (T value)
 
template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_unsigned< T >::value &&(etl::integral_limits< T >::bits==32U), T >::type reverse_bytes (T value)
 
template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_unsigned< T >::value &&(etl::integral_limits< T >::bits==64U), T >::type reverse_bytes (T value)
 
template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_signed< T >::value, T >::type reverse_bytes (T value)
 
template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_unsigned< T >::value &&(etl::integral_limits< T >::bits==16U), T >::type gray_to_binary (T value)
 
template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_unsigned< T >::value &&(etl::integral_limits< T >::bits==32U), T >::type gray_to_binary (T value)
 
template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_unsigned< T >::value &&(etl::integral_limits< T >::bits==64U), T >::type gray_to_binary (T value)
 
template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_signed< T >::value, T >::type gray_to_binary (T value)
 
template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_unsigned< T >::value &&(etl::integral_limits< T >::bits==16U), uint_least8_t >::type count_bits (T value)
 
template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_unsigned< T >::value &&(etl::integral_limits< T >::bits==32U), uint_least8_t >::type count_bits (T value)
 
template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_unsigned< T >::value &&(etl::integral_limits< T >::bits==64U), uint_least8_t >::type count_bits (T value)
 
template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_signed< T >::value, uint_least8_t >::type count_bits (T value)
 
template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_unsigned< T >::value &&(etl::integral_limits< T >::bits==16U), uint_least8_t >::type parity (T value)
 
template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_unsigned< T >::value &&(etl::integral_limits< T >::bits==32U), uint_least8_t >::type parity (T value)
 
template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_unsigned< T >::value &&(etl::integral_limits< T >::bits==64U), uint_least8_t >::type parity (T value)
 
template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_signed< T >::value, uint_least8_t >::type parity (T value)
 
template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_unsigned< T >::value &&(etl::integral_limits< T >::bits==16U), uint_least8_t >::type count_trailing_zeros (T value)
 
template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_unsigned< T >::value &&(etl::integral_limits< T >::bits==32U), uint_least8_t >::type count_trailing_zeros (T value)
 
template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_unsigned< T >::value &&(etl::integral_limits< T >::bits==64U), uint_least8_t >::type count_trailing_zeros (T value)
 
template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_signed< T >::value, uint_least8_t >::type count_trailing_zeros (T value)
 
template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_unsigned< T >::value &&(etl::integral_limits< T >::bits==16U), uint_least8_t >::type count_trailing_ones (T value)
 
template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_unsigned< T >::value &&(etl::integral_limits< T >::bits==32U), uint_least8_t >::type count_trailing_ones (T value)
 
template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_unsigned< T >::value &&(etl::integral_limits< T >::bits==64U), uint_least8_t >::type count_trailing_ones (T value)
 
template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_signed< T >::value, uint_least8_t >::type count_trailing_ones (T value)
 
template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_unsigned< T >::value &&(etl::integral_limits< T >::bits==16U), uint_least8_t >::type count_leading_zeros (T value)
 
template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_unsigned< T >::value &&(etl::integral_limits< T >::bits==32U), uint_least8_t >::type count_leading_zeros (T value)
 
template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_unsigned< T >::value &&(etl::integral_limits< T >::bits==64U), uint_least8_t >::type count_leading_zeros (T value)
 
template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_signed< T >::value, uint_least8_t >::type count_leading_zeros (T value)
 
template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_unsigned< T >::value &&(etl::integral_limits< T >::bits==16U), uint_least8_t >::type count_leading_ones (T value)
 
template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_unsigned< T >::value &&(etl::integral_limits< T >::bits==32U), uint_least8_t >::type count_leading_ones (T value)
 
template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_unsigned< T >::value &&(etl::integral_limits< T >::bits==64U), uint_least8_t >::type count_leading_ones (T value)
 
template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_signed< T >::value, uint_least8_t >::type count_leading_ones (T value)
 
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 T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_unsigned< T >::value &&(etl::integral_limits< T >::bits==16U), uint32_t >::type binary_interleave (T first, T second)
 
template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_unsigned< T >::value &&(etl::integral_limits< T >::bits==32U), uint64_t >::type binary_interleave (T first, T second)
 
template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_signed< T >::value, T >::type binary_interleave (T first, T second)
 
template<typename T >
ETL_CONSTEXPR etl::enable_if< etl::is_integral< T >::value, bool >::type is_odd (T value)
 
template<typename T >
ETL_CONSTEXPR etl::enable_if< etl::is_integral< T >::value, bool >::type is_even (T value)
 
template<typename T , size_t NBits>
ETL_CONSTEXPR T make_lsb_mask ()
 
template<typename T >
ETL_CONSTEXPR T make_lsb_mask (size_t nbits)
 
template<typename T >
ETL_CONSTEXPR T make_msb_mask (size_t nbits)
 
template<typename T , size_t NBits>
ETL_CONSTEXPR T make_msb_mask ()
 
template<typename TDestination , typename TSource >
ETL_NODISCARD etl::enable_if<!(etl::is_integral< TDestination >::value &&etl::is_integral< TSource >::value)&&(sizeof(TDestination)==sizeof(TSource))&&etl::is_trivially_copyable< TSource >::value &&etl::is_trivially_copyable< TDestination >::value, TDestination >::type bit_cast (const TSource &source) ETL_NOEXCEPT
 bit_cast - Type to different type.
 
template<typename TDestination , typename TSource >
ETL_NODISCARD ETL_CONSTEXPR14 etl::enable_if<(etl::is_integral< TDestination >::value &&etl::is_integral< TSource >::value)&&(sizeof(TDestination)==sizeof(TSource)), TDestination >::type bit_cast (const TSource &source) ETL_NOEXCEPT
 bit_cast - Integral to integral
 
template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value, T >::type byteswap (T value) ETL_NOEXCEPT
 byteswap
 
template<typename T >
ETL_NODISCARD ETL_CONSTEXPR14 etl::enable_if< etl::is_unsigned< T >::value, bool >::type has_single_bit (T value) ETL_NOEXCEPT
 has_single_bit
 
template<typename T >
ETL_NODISCARD ETL_CONSTEXPR14 etl::enable_if< etl::is_unsigned< T >::value, int >::type countl_zero (T value) ETL_NOEXCEPT
 countl_zero
 
template<typename T >
ETL_NODISCARD ETL_CONSTEXPR14 etl::enable_if< etl::is_unsigned< T >::value, int >::type countl_one (T value) ETL_NOEXCEPT
 countl_one
 
template<typename T >
ETL_NODISCARD ETL_CONSTEXPR14 etl::enable_if< etl::is_unsigned< T >::value, int >::type countr_zero (T value) ETL_NOEXCEPT
 countr_zero
 
template<typename T >
ETL_NODISCARD ETL_CONSTEXPR14 etl::enable_if< etl::is_unsigned< T >::value, int >::type countr_one (T value) ETL_NOEXCEPT
 countr_one
 
template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_unsigned< T >::value, T >::type bit_width (T value) ETL_NOEXCEPT
 bit_width
 
template<typename T >
ETL_NODISCARD ETL_CONSTEXPR14 etl::enable_if< etl::is_unsigned< T >::value, T >::type bit_ceil (T value)
 bit_ceil
 
template<typename T >
ETL_NODISCARD ETL_CONSTEXPR14 etl::enable_if< etl::is_unsigned< T >::value, T >::type bit_floor (T value) ETL_NOEXCEPT
 bit_floor
 
template<typename T >
ETL_NODISCARD ETL_CONSTEXPR14 etl::enable_if< etl::is_unsigned< T >::value, T >::type rotl (T value, int n) ETL_NOEXCEPT
 rotl
 
template<typename T >
ETL_NODISCARD ETL_CONSTEXPR14 etl::enable_if< etl::is_unsigned< T >::value, T >::type rotr (T value, int n) ETL_NOEXCEPT
 rotr
 
template<typename T >
ETL_NODISCARD ETL_CONSTEXPR14 etl::enable_if< etl::is_unsigned< T >::value, int >::type popcount (T value) ETL_NOEXCEPT
 popcount
 
void write_unchecked (etl::bit_stream_writer &stream, bool value)
 
bool write (etl::bit_stream_writer &stream, bool value)
 
template<typename T >
etl::enable_if< etl::is_integral< T >::value, void >::type write_unchecked (etl::bit_stream_writer &stream, const T &value, uint_least8_t nbits=CHAR_BIT *sizeof(T))
 
template<typename T >
etl::enable_if< etl::is_integral< T >::value, bool >::type write (etl::bit_stream_writer &stream, const T &value, uint_least8_t nbits=CHAR_BIT *sizeof(T))
 
template<typename T >
T read_unchecked (etl::bit_stream_reader &stream)
 Read an unchecked type from a stream.
 
template<typename T >
T read_unchecked (etl::bit_stream_reader &stream, uint_least8_t nbits)
 
template<typename T >
etl::optional< Tread (etl::bit_stream_reader &stream)
 Read a checked type from a stream.
 
template<typename T >
etl::optional< Tread (etl::bit_stream_reader &stream, uint_least8_t nbits)
 
template<>
bool read_unchecked< bool > (etl::bit_stream_reader &stream)
 Read an unchecked bool from a stream.
 
template<>
etl::optional< boolread< bool > (etl::bit_stream_reader &stream)
 Read a bool from a stream.
 
bool operator== (etl::byte lhs, etl::byte rhs)
 Equality test.
 
bool operator!= (etl::byte lhs, etl::byte rhs)
 Inequality test.
 
template<typename TInteger >
etl::enable_if< etl::is_integral< TInteger >::value, TInteger >::type to_integer (etl::byte b)
 To integer.
 
template<typename TInteger >
etl::enable_if< etl::is_integral< TInteger >::value, etl::byte >::type operator<< (etl::byte b, TInteger shift)
 Shift left.
 
template<typename TInteger >
etl::enable_if< etl::is_integral< TInteger >::value, etl::byte >::type operator>> (etl::byte b, TInteger shift)
 Shift right.
 
template<typename TInteger >
etl::enable_if< etl::is_integral< TInteger >::value, etl::byte & >::type operator<<= (etl::byte &b, TInteger shift)
 Shift left equals.
 
template<typename TInteger >
etl::enable_if< etl::is_integral< TInteger >::value, etl::byte & >::type operator>>= (etl::byte &b, TInteger shift)
 Shift right equals.
 
etl::byte operator| (etl::byte lhs, etl::byte rhs)
 Or.
 
etl::byte operator& (etl::byte lhs, etl::byte rhs)
 And.
 
etl::byte operator^ (etl::byte lhs, etl::byte rhs)
 Exclusive Or.
 
etl::byteoperator|= (etl::byte &lhs, etl::byte rhs)
 Or equals.
 
etl::byteoperator&= (etl::byte &lhs, etl::byte rhs)
 And equals.
 
etl::byteoperator^= (etl::byte &lhs, etl::byte rhs)
 Exclusive or equals.
 
etl::byte operator~ (etl::byte b)
 Not.
 
template<typename T >
void write_unchecked (etl::byte_stream_writer &stream, const T &value)
 
template<typename T >
bool write (etl::byte_stream_writer &stream, const T &value)
 Implementation of the write function.
 
template<typename T >
T read_unchecked (etl::byte_stream_reader &stream)
 
template<typename T >
etl::optional< Tread (etl::byte_stream_reader &stream)
 Implementation of the read function.
 
template<typename T >
ETL_CONSTEXPR14 size_t strlen (const T *t)
 Alternative strlen for all character types.
 
template<typename T >
ETL_CONSTEXPR14 size_t strlen (const T *t, size_t max_length)
 Alternative strlen for all character types, with maximum length.
 
template<typename T >
ETL_CONSTEXPR14 int strcmp (const T *t1, const T *t2)
 Alternative strcmp for all character types.
 
template<typename T >
ETL_CONSTEXPR14 int strncmp (const T *t1, const T *t2, size_t n)
 Alternative strncmp for all character types.
 
template<typename T >
ETL_CONSTEXPR14 Tstrcpy (T *dst, const T *src)
 Alternative strcpy for all character types.
 
template<typename T >
ETL_CONSTEXPR14 Tstrncpy (T *dst, const T *src, size_t n)
 Alternative strncpy for all character types.
 
template<typename T >
void swap (etl::circular_buffer_ext< T > &lhs, etl::circular_buffer_ext< T > &rhs)
 Template deduction guides.
 
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 TIterator >
ETL_CONSTEXPR14 etl::circular_iterator< TIteratoroperator+ (etl::circular_iterator< TIterator > &lhs, typename etl::iterator_traits< TIterator >::difference_type offset)
 
template<typename TIterator >
ETL_CONSTEXPR14 etl::circular_iterator< TIteratoroperator- (etl::circular_iterator< TIterator > &lhs, typename etl::iterator_traits< TIterator >::difference_type offset)
 
template<typename TIterator >
ETL_CONSTEXPR14 etl::iterator_traits< TIterator >::difference_type operator- (etl::circular_iterator< TIterator > &lhs, etl::circular_iterator< TIterator > &rhs)
 
template<typename TIterator >
ETL_CONSTEXPR14 bool operator== (const etl::circular_iterator< TIterator > &lhs, const etl::circular_iterator< TIterator > &rhs)
 Equality operator. circular_iterator == circular_iterator.
 
template<typename TIterator >
ETL_CONSTEXPR14 bool operator== (const etl::circular_iterator< TIterator > &lhs, TIterator rhs)
 Equality operator. circular_iterator == iterator.
 
template<typename TIterator >
ETL_CONSTEXPR14 bool operator== (TIterator lhs, const etl::circular_iterator< TIterator > &rhs)
 Equality operator. iterator == circular_iterator.
 
template<typename TIterator >
ETL_CONSTEXPR14 bool operator!= (const etl::circular_iterator< TIterator > &lhs, const etl::circular_iterator< TIterator > &rhs)
 Inequality operator. circular_iterator == circular_iterator.
 
template<typename TIterator >
ETL_CONSTEXPR14 bool operator!= (const etl::circular_iterator< TIterator > &lhs, TIterator rhs)
 Inequality operator. circular_iterator == iterator.
 
template<typename TIterator >
ETL_CONSTEXPR14 bool operator!= (TIterator &lhs, const etl::circular_iterator< TIterator > &rhs)
 Inequality operator. iterator == circular_iterator.
 
template<typename T , typename TLess >
ETL_CONSTEXPR14 int three_way_compare (const T &lhs, const T &rhs)
 Default implementation of TLess is etl::less.
 
template<typename T >
bool operator== (const etl::ideque< T > &lhs, const etl::ideque< T > &rhs)
 Template deduction guides.
 
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)
 
template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value, T >::type ntoh (T value)
 
template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value, T >::type hton (T value)
 
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- (const etl::fixed_iterator< TIterator > &lhs, const 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< Tref (T &t)
 
template<typename T >
reference_wrapper< Tref (reference_wrapper< T > t)
 
template<typename T >
reference_wrapper< const Tcref (const T &t)
 
template<typename T >
reference_wrapper< const Tcref (reference_wrapper< T > t)
 
template<typename F , typename T >
binder1st< Fbind1st (const F &f, const T &x)
 
template<typename F , typename T >
binder2nd< Fbind2nd (const F &f, const T &x)
 
template<typename T >
ETL_NODISCARD ETL_CONSTEXPR14 etl::enable_if< etl::is_unsigned< T >::value, T >::type gcd (T a, T b) ETL_NOEXCEPT
 
template<typename T >
ETL_NODISCARD ETL_CONSTEXPR14 etl::enable_if< etl::is_signed< T >::value, T >::type gcd (T a, T b) ETL_NOEXCEPT
 
cog outl (" : valid(true)") cog.outl("
 
cog outl ("#include \"private/diagnostic_pop.h\"") cog.outl(" cog.outl(" cog.outl(" cog.outl(" template< typename TMessage >") cog.out(" explicit message_packet(const TMessage &
 
etl::imessage_routerget_null_message_router ()
 null message router functionality.
 
 variant_pool ()
 Default constructor.
 
template<typename T , typename... Args>
Tcreate (Args &&... args)
 Creates the object from a type. Variadic parameter constructor.
 
template<typename T >
void destroy (const T *const p)
 Destroys the object.
 
size_t max_size () const
 Returns the maximum number of items in the variant_pool.
 
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_forward_link< TLink >::value, void >::type link (TLink &lhs, TLink &rhs)
 
template<typename TLink >
etl::enable_if< etl::is_forward_link< TLink >::value, void >::type link (TLink *lhs, TLink *rhs)
 
template<typename TLink >
etl::enable_if< etl::is_forward_link< TLink >::value, void >::type link (TLink &lhs, TLink *rhs)
 
template<typename TLink >
etl::enable_if< etl::is_forward_link< TLink >::value, void >::type link (TLink *lhs, TLink &rhs)
 
template<typename TLink >
etl::enable_if< etl::is_forward_link< TLink >::value, void >::type link_splice (TLink &lhs, TLink &rhs)
 
template<typename TLink >
etl::enable_if< etl::is_forward_link< TLink >::value, void >::type link_splice (TLink *lhs, TLink *rhs)
 
template<typename TLink >
etl::enable_if< etl::is_forward_link< TLink >::value, void >::type link_splice (TLink &lhs, TLink *rhs)
 
template<typename TLink >
etl::enable_if< etl::is_forward_link< TLink >::value, void >::type link_splice (TLink *lhs, TLink &rhs)
 
template<typename TLink >
etl::enable_if< etl::is_forward_link< TLink >::value, void >::type link_splice (TLink &lhs, TLink &first, TLink &last)
 
template<typename TLink >
etl::enable_if< etl::is_forward_link< TLink >::value, void >::type link_splice (TLink *lhs, TLink &first, TLink &last)
 
template<typename TLink >
etl::enable_if< etl::is_forward_link< TLink >::value, TLink * >::type unlink_after (TLink &node)
 
template<typename TLink >
etl::enable_if< etl::is_forward_link< TLink >::value, TLink * >::type unlink_after (TLink &before, TLink &last)
 
template<typename TLink >
etl::enable_if< etl::is_forward_link< TLink >::value, bool >::type is_linked (TLink &node)
 
template<typename TLink >
etl::enable_if< etl::is_forward_link< TLink >::value, bool >::type is_linked (TLink *node)
 
template<typename TLink >
etl::enable_if< etl::is_forward_link< TLink >::value, void >::type link_clear (TLink &start)
 
template<typename TLink >
etl::enable_if< etl::is_forward_link< TLink >::value, void >::type link_clear (TLink *start)
 
template<typename TLink >
etl::enable_if< etl::is_forward_link< TLink >::value, void >::type link_clear_range (TLink &start)
 
template<typename TLink >
etl::enable_if< etl::is_forward_link< TLink >::value, void >::type link_clear_range (TLink *start)
 
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 (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 (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 *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 &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, TLink & >::type unlink (TLink &first, TLink &last)
 
template<typename TLink >
etl::enable_if< etl::is_same< TLink, etl::bidirectional_link< TLink::ID > >::value, bool >::type is_linked (TLink &node)
 
template<typename TLink >
etl::enable_if< etl::is_same< TLink, etl::bidirectional_link< TLink::ID > >::value, bool >::type is_linked (TLink *node)
 
template<typename TLink >
etl::enable_if< etl::is_same< TLink, etl::bidirectional_link< TLink::ID > >::value, void >::type link_clear_range (TLink &start)
 
template<typename TLink >
etl::enable_if< etl::is_same< TLink, etl::bidirectional_link< TLink::ID > >::value, void >::type link_clear_range (TLink *start)
 
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_left (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_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_right (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_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_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_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_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_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_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_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 TLink >
etl::enable_if< etl::is_same< TLink, etl::tree_link< TLink::ID > >::value, void >::type link_clear (TLink &node)
 
template<typename TLink >
etl::enable_if< etl::is_same< TLink, etl::tree_link< TLink::ID > >::value, void >::type link_clear (TLink *node)
 
template<typename TLink >
etl::enable_if< etl::is_same< TLink, etl::tree_link< TLink::ID > >::value, bool >::type is_linked (TLink &node)
 
template<typename TLink >
etl::enable_if< etl::is_same< TLink, etl::tree_link< TLink::ID > >::value, bool >::type is_linked (TLink *node)
 
template<typename TIterator , typename TDistance >
ETL_CONSTEXPR14 void advance_helper (TIterator &itr, TDistance n, ETL_OR_STD::output_iterator_tag)
 
template<typename TIterator , typename TDistance >
ETL_CONSTEXPR14 void advance_helper (TIterator &itr, TDistance n, ETL_OR_STD::forward_iterator_tag)
 
template<typename TIterator , typename TDistance >
ETL_CONSTEXPR14 void advance_helper (TIterator &itr, TDistance n, ETL_OR_STD::bidirectional_iterator_tag)
 
template<typename TIterator , typename TDistance >
ETL_CONSTEXPR14 void advance_helper (TIterator &itr, TDistance n, ETL_OR_STD::random_access_iterator_tag)
 
template<typename TIterator , typename TDistance >
ETL_CONSTEXPR14 void advance (TIterator &itr, TDistance n)
 
template<typename TIterator >
ETL_CONSTEXPR14 etl::iterator_traits< TIterator >::difference_type distance_helper (TIterator first, TIterator last, ETL_OR_STD::input_iterator_tag)
 
template<typename TIterator >
ETL_CONSTEXPR14 etl::iterator_traits< TIterator >::difference_type distance_helper (TIterator first, TIterator last, ETL_OR_STD::forward_iterator_tag)
 
template<typename TIterator >
ETL_CONSTEXPR14 etl::iterator_traits< TIterator >::difference_type distance_helper (TIterator first, TIterator last, ETL_OR_STD::bidirectional_iterator_tag)
 
template<typename TIterator >
ETL_CONSTEXPR14 etl::iterator_traits< TIterator >::difference_type distance_helper (TIterator first, TIterator last, ETL_OR_STD::random_access_iterator_tag)
 
template<typename TIterator >
ETL_CONSTEXPR14 etl::iterator_traits< TIterator >::difference_type distance (TIterator first, TIterator last)
 
template<typename TIterator >
ETL_CONSTEXPR14 TIterator prev (TIterator itr, typename etl::iterator_traits< TIterator >::difference_type n=1)
 
template<typename TIterator >
ETL_CONSTEXPR14 TIterator next (TIterator itr, typename etl::iterator_traits< TIterator >::difference_type n=1)
 
template<typename TIterator >
ETL_CONSTEXPR14 bool operator== (const reverse_iterator< TIterator > &lhs, const reverse_iterator< TIterator > &rhs)
 
template<typename TIterator >
ETL_CONSTEXPR14 bool operator!= (const reverse_iterator< TIterator > &lhs, const reverse_iterator< TIterator > &rhs)
 
template<typename TIterator >
ETL_CONSTEXPR14 bool operator< (const reverse_iterator< TIterator > &lhs, const reverse_iterator< TIterator > &rhs)
 
template<typename TIterator >
ETL_CONSTEXPR14 bool operator> (const reverse_iterator< TIterator > &lhs, const reverse_iterator< TIterator > &rhs)
 
template<typename TIterator >
ETL_CONSTEXPR14 bool operator<= (const reverse_iterator< TIterator > &lhs, const reverse_iterator< TIterator > &rhs)
 
template<typename TIterator >
ETL_CONSTEXPR14 bool operator>= (const reverse_iterator< TIterator > &lhs, const reverse_iterator< TIterator > &rhs)
 
template<typename TIterator >
ETL_CONSTEXPR14 reverse_iterator< TIterator >::difference_type operator- (const reverse_iterator< TIterator > &lhs, const reverse_iterator< TIterator > &rhs)
 
template<typename TIterator , class TDifference >
ETL_CONSTEXPR14 reverse_iterator< TIteratoroperator+ (TDifference n, const reverse_iterator< TIterator > &itr)
 
template<typename TContainer >
ETL_NODISCARD ETL_CONSTEXPR14 etl::back_insert_iterator< TContainerback_inserter (TContainer &container)
 Creates a back_insert_iterator from a container.
 
template<typename TContainer >
ETL_NODISCARD ETL_CONSTEXPR14 etl::front_insert_iterator< TContainerfront_inserter (TContainer &container)
 Creates a front_insert_iterator from a container.
 
template<typename TContainer >
ETL_NODISCARD ETL_CONSTEXPR14 etl::push_insert_iterator< TContainerpush_inserter (TContainer &container)
 Creates a push_insert_iterator from a container.
 
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::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 TValue , size_t Array_Size>
ETL_CONSTEXPR TValuebegin (TValue(&data)[Array_Size])
 
template<typename TValue , size_t Array_Size>
ETL_CONSTEXPR const TValuebegin (const TValue(&data)[Array_Size])
 
template<typename TValue , size_t Array_Size>
ETL_CONSTEXPR const TValuecbegin (const TValue(&data)[Array_Size])
 
template<typename TValue , size_t Array_Size>
ETL_CONSTEXPR TValueend (TValue(&data)[Array_Size])
 
template<typename TValue , size_t Array_Size>
ETL_CONSTEXPR const TValueend (const TValue(&data)[Array_Size])
 
template<typename TValue , size_t Array_Size>
ETL_CONSTEXPR const TValuecend (const TValue(&data)[Array_Size])
 
template<typename TContainer >
ETL_CONSTEXPR TContainer::reverse_iterator rbegin (TContainer &container)
 
template<typename TContainer >
ETL_CONSTEXPR TContainer::const_reverse_iterator rbegin (const TContainer &container)
 
template<typename TContainer >
ETL_CONSTEXPR TContainer::const_reverse_iterator crbegin (const TContainer &container)
 
template<typename TContainer >
ETL_CONSTEXPR TContainer::reverse_iterator rend (TContainer &container)
 
template<typename TContainer >
ETL_CONSTEXPR TContainer::const_reverse_iterator rend (const TContainer &container)
 
template<typename TContainer >
ETL_CONSTEXPR TContainer::const_reverse_iterator crend (const TContainer &container)
 
template<typename TValue , size_t Array_Size>
ETL_OR_STD::reverse_iterator< TValue * > rbegin (TValue(&data)[Array_Size])
 
template<typename TValue , size_t Array_Size>
ETL_CONSTEXPR ETL_OR_STD::reverse_iterator< const TValue * > crbegin (const TValue(&data)[Array_Size])
 
template<typename TValue , size_t Array_Size>
ETL_CONSTEXPR ETL_OR_STD::reverse_iterator< TValue * > rend (TValue(&data)[Array_Size])
 
template<typename TValue , 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 , size_t Array_Size>
ETL_CONSTEXPR size_t size (TValue(&)[Array_Size])
 
template<typename T , size_t Array_Size>
char(& array_size (T(&array)[Array_Size]))[Array_Size]
 
template<typename T >
ETL_NODISCARD ETL_CONSTEXPR14 etl::enable_if< etl::is_unsigned< T >::value, T >::type lcm (T a, T b) ETL_NOEXCEPT
 
template<typename T >
ETL_NODISCARD ETL_CONSTEXPR14 etl::enable_if< etl::is_signed< T >::value, T >::type lcm (T a, T b) ETL_NOEXCEPT
 
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.
 
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 >
ETL_CONSTEXPR etl::enable_if< etl::is_floating_point< T >::value, bool >::type is_nan (T value)
 
template<typename T >
ETL_CONSTEXPR etl::enable_if< etl::is_integral< T >::value, bool >::type is_nan (T)
 
template<typename T >
ETL_CONSTEXPR etl::enable_if< etl::is_floating_point< T >::value, bool >::type is_infinity (T value)
 
template<typename T >
ETL_CONSTEXPR etl::enable_if< etl::is_integral< T >::value, bool >::type is_infinity (T)
 
template<typename T >
ETL_CONSTEXPR etl::enable_if< etl::is_floating_point< T >::value, bool >::type is_zero (T value)
 
template<typename T >
ETL_CONSTEXPR etl::enable_if< etl::is_integral< T >::value, bool >::type is_zero (T value)
 
template<typename T >
ETL_CONSTEXPR bool is_exactly_equal (T value1, T value2)
 
template<typename T >
ETL_CONSTEXPR Tto_address (T *p)
 
template<typename Iterator >
ETL_CONSTEXPR Iterator::pointer to_address (const Iterator &itr)
 
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< typenameetl::iterator_traits< TOutputIterator >::value_type >::value, void >::type uninitialized_default_construct (TOutputIterator, TOutputIterator)
 
template<typename TOutputIterator >
etl::enable_if<!etl::is_trivially_constructible< typenameetl::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< typenameetl::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< typenameetl::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< typenameetl::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< typenameetl::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< typenameetl::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< typenameetl::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< typenameetl::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< typenameetl::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 >
Tconstruct_at (T *p)
 
template<typename T , typename TArg >
Tconstruct_at (T *p, const TArg &arg)
 
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< typenameetl::iterator_traits< TIterator >::value_type >::value, void >::type destroy (TIterator, TIterator)
 
template<typename TIterator >
etl::enable_if<!etl::is_trivially_destructible< typenameetl::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< typenameetl::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< typenameetl::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< typenameetl::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< typenameetl::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< typenameetl::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< typenameetl::iterator_traits< TIterator >::value_type >::value, TIterator >::type destroy_n (TIterator i_begin, TSize n, TCounter &count)
 
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.
 
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.
 
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 >
ETL_CONSTEXPR14 void iota (TIterator first, TIterator last, T value)
 
template<typename T >
ETL_CONSTEXPR14 etl::enable_if<!etl::is_pointer< T >::value &&!etl::is_integral< T >::value &&etl::is_floating_point< T >::value, T >::type midpoint (T a, T b) ETL_NOEXCEPT
 
template<typename T >
ETL_CONSTEXPR14 etl::enable_if<!etl::is_pointer< T >::value &&etl::is_integral< T >::value &&!etl::is_floating_point< T >::value &&etl::is_unsigned< T >::value, T >::type midpoint (T a, T b) ETL_NOEXCEPT
 
template<typename T >
ETL_CONSTEXPR14 etl::enable_if<!etl::is_pointer< T >::value &&etl::is_integral< T >::value &&!etl::is_floating_point< T >::value &&etl::is_signed< T >::value, T >::type midpoint (T a, T b) ETL_NOEXCEPT
 
template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_pointer< T >::value &&!etl::is_integral< T >::value &&!etl::is_floating_point< T >::value, T >::type midpoint (T a, T b) ETL_NOEXCEPT
 
template<typename T >
ETL_CONSTEXPR14 T midpoint (T a, T b, typename etl::enable_if<!etl::is_pointer< T >::value &&!etl::is_integral< T >::value &&!etl::is_floating_point< T >::value &&etl::is_same< typename etl::iterator_traits< T >::iterator_category, ETL_OR_STD::random_access_iterator_tag >::value, int >::type=0)
 
template<typename T >
ETL_CONSTEXPR14 T midpoint (T a, T b, typename etl::enable_if<(!etl::is_pointer< T >::value &&!etl::is_integral< T >::value &&!etl::is_floating_point< T >::value &&(etl::is_same< typename etl::iterator_traits< T >::iterator_category, ETL_OR_STD::forward_iterator_tag >::value||etl::is_same< typename etl::iterator_traits< T >::iterator_category, ETL_OR_STD::bidirectional_iterator_tag >::value)), int >::type=0)
 
template<typename T >
ETL_CONSTEXPR etl::enable_if< etl::is_floating_point< T >::value, T >::type lerp (T a, T b, T t) ETL_NOEXCEPT
 
template<typename TArithmetic1 , typename TArithmetic2 , typename TArithmetic3 >
ETL_CONSTEXPR etl::enable_if<!etl::is_floating_point< TArithmetic1 >::value||!etl::is_floating_point< TArithmetic2 >::value||!etl::is_floating_point< TArithmetic3 >::value, typenameetl::conditional< etl::is_same< TArithmetic1, longdouble >::value||etl::is_same< TArithmetic2, longdouble >::value||etl::is_same< TArithmetic3, longdouble >::value, longdouble, double >::type >::type lerp (TArithmetic1 a, TArithmetic2 b, TArithmetic3 t) ETL_NOEXCEPT
 
template<typename T >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator== (const etl::optional< T > &lhs, const etl::optional< T > &rhs)
 Equality operator. cppreference 1.
 
template<typename T >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator== (const etl::optional< T > &lhs, const etl::optional< T > &rhs)
 Equality operator. cppreference 1.
 
template<typename T >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator!= (const etl::optional< T > &lhs, const etl::optional< T > &rhs)
 Inequality operator. cppreference 2.
 
template<typename T >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator!= (const etl::optional< T > &lhs, const etl::optional< T > &rhs)
 Inequality operator. cppreference 2.
 
template<typename T >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator< (const etl::optional< T > &lhs, const etl::optional< T > &rhs)
 Less than operator. cppreference 3.
 
template<typename T >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator< (const etl::optional< T > &lhs, const etl::optional< T > &rhs)
 Less than operator. cppreference 3.
 
template<typename T >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator<= (const etl::optional< T > &lhs, const etl::optional< T > &rhs)
 Less than equal operator. cppreference 4.
 
template<typename T >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator<= (const etl::optional< T > &lhs, const etl::optional< T > &rhs)
 Less than equal operator. cppreference 4.
 
template<typename T >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator> (const etl::optional< T > &lhs, const etl::optional< T > &rhs)
 greater than operator. cppreference 5
 
template<typename T >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator> (const etl::optional< T > &lhs, const etl::optional< T > &rhs)
 greater than operator. cppreference 5
 
template<typename T >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator>= (const etl::optional< T > &lhs, const etl::optional< T > &rhs)
 greater than equal operator. cppreference 6
 
template<typename T >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator>= (const etl::optional< T > &lhs, const etl::optional< T > &rhs)
 greater than equal operator. cppreference 6
 
template<typename T >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator== (const etl::optional< T > &lhs, etl::nullopt_t)
 Equality operator. cppreference 7.
 
template<typename T >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator== (const etl::optional< T > &lhs, etl::nullopt_t)
 Equality operator. cppreference 7.
 
template<typename T >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator== (etl::nullopt_t, const etl::optional< T > &rhs)
 Equality operator. cppreference 8.
 
template<typename T >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator== (etl::nullopt_t, const etl::optional< T > &rhs)
 Equality operator. cppreference 8.
 
template<typename T >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator!= (const etl::optional< T > &lhs, etl::nullopt_t)
 Inequality operator. cppreference 9.
 
template<typename T >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator!= (const etl::optional< T > &lhs, etl::nullopt_t)
 Inequality operator. cppreference 9.
 
template<typename T >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator!= (etl::nullopt_t, const etl::optional< T > &rhs)
 Inequality operator. cppreference 10.
 
template<typename T >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator!= (etl::nullopt_t, const etl::optional< T > &rhs)
 Inequality operator. cppreference 10.
 
template<typename T >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator< (const etl::optional< T > &, etl::nullopt_t)
 Less than operator. cppreference 11.
 
template<typename T >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator< (const etl::optional< T > &, etl::nullopt_t)
 Less than operator. cppreference 11.
 
template<typename T >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator< (etl::nullopt_t, const etl::optional< T > &rhs)
 Less than operator. cppreference 12.
 
template<typename T >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator< (etl::nullopt_t, const etl::optional< T > &rhs)
 Less than operator. cppreference 12.
 
template<typename T >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator<= (const etl::optional< T > &lhs, etl::nullopt_t)
 Less than equal operator. cppreference 13.
 
template<typename T >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator<= (const etl::optional< T > &lhs, etl::nullopt_t)
 Less than equal operator. cppreference 13.
 
template<typename T >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator<= (etl::nullopt_t, const etl::optional< T > &)
 Less than equal operator. cppreference 14.
 
template<typename T >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator<= (etl::nullopt_t, const etl::optional< T > &)
 Less than equal operator. cppreference 14.
 
template<typename T >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator> (const etl::optional< T > &lhs, etl::nullopt_t)
 Greater than operator. cppreference 15.
 
template<typename T >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator> (const etl::optional< T > &lhs, etl::nullopt_t)
 Greater than operator. cppreference 15.
 
template<typename T >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator> (etl::nullopt_t, const etl::optional< T > &)
 Greater than operator. cppreference 16.
 
template<typename T >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator> (etl::nullopt_t, const etl::optional< T > &)
 Greater than operator. cppreference 16.
 
template<typename T >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator>= (const etl::optional< T > &, etl::nullopt_t)
 Greater than equal operator. cppreference 17.
 
template<typename T >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator>= (const etl::optional< T > &, etl::nullopt_t)
 Greater than equal operator. cppreference 17.
 
template<typename T >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator>= (etl::nullopt_t, const etl::optional< T > &rhs)
 Greater than equal operator. cppreference 18.
 
template<typename T >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator>= (etl::nullopt_t, const etl::optional< T > &rhs)
 Greater than equal operator. cppreference 18.
 
template<typename T , typename U >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator== (const etl::optional< T > &lhs, const U &rhs)
 Equality operator. cppreference 19.
 
template<typename T , typename U >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator== (const etl::optional< T > &lhs, const U &rhs)
 Equality operator. cppreference 19.
 
template<typename T , typename U >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator!= (const etl::optional< T > &lhs, const U &rhs)
 Inequality operator. cppreference 21.
 
template<typename T , typename U >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator!= (const etl::optional< T > &lhs, const U &rhs)
 Inequality operator. cppreference 21.
 
template<typename T , typename U >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator== (const U &lhs, const etl::optional< T > &rhs)
 Equality operator. cppreference 20.
 
template<typename T , typename U >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator== (const U &lhs, const etl::optional< T > &rhs)
 Equality operator. cppreference 20.
 
template<typename T , typename U >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator!= (const U &lhs, const etl::optional< T > &rhs)
 Inequality operator. cppreference 22.
 
template<typename T , typename U >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator!= (const U &lhs, const etl::optional< T > &rhs)
 Inequality operator. cppreference 22.
 
template<typename T , typename U >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator< (const etl::optional< T > &lhs, const U &rhs)
 Less than operator. cppreference 23.
 
template<typename T , typename U >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator< (const etl::optional< T > &lhs, const U &rhs)
 Less than operator. cppreference 23.
 
template<typename T , typename U >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator< (const U &lhs, const etl::optional< T > &rhs)
 Less than operator. cppreference 24.
 
template<typename T , typename U >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator< (const U &lhs, const etl::optional< T > &rhs)
 Less than operator. cppreference 24.
 
template<typename T , typename U >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator<= (const etl::optional< T > &lhs, const U &rhs)
 Less than equal operator. cppreference 25.
 
template<typename T , typename U >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator<= (const etl::optional< T > &lhs, const U &rhs)
 Less than equal operator. cppreference 25.
 
template<typename T , typename U >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator<= (const U &lhs, const etl::optional< T > &rhs)
 Less than equal operator. cppreference 26.
 
template<typename T , typename U >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator<= (const U &lhs, const etl::optional< T > &rhs)
 Less than equal operator. cppreference 26.
 
template<typename T , typename U >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator> (const etl::optional< T > &lhs, const U &rhs)
 Greater than operator. cppreference 27.
 
template<typename T , typename U >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator> (const etl::optional< T > &lhs, const U &rhs)
 Greater than operator. cppreference 27.
 
template<typename T , typename U >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator> (const U &lhs, const etl::optional< T > &rhs)
 Greater than operator. cppreference 28.
 
template<typename T , typename U >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator> (const U &lhs, const etl::optional< T > &rhs)
 Greater than operator. cppreference 28.
 
template<typename T , typename U >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator>= (const etl::optional< T > &lhs, const U &rhs)
 Greater than equal operator. cppreference 29.
 
template<typename T , typename U >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator>= (const etl::optional< T > &lhs, const U &rhs)
 Greater than equal operator. cppreference 29.
 
template<typename T , typename U >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP14 operator>= (const U &lhs, const etl::optional< T > &rhs)
 Greater than equal operator. cppreference 30.
 
template<typename T , typename U >
ETL_OPTIONAL_ENABLE_CONSTEXPR_BOOL_RETURN_CPP20_STL operator>= (const U &lhs, const etl::optional< T > &rhs)
 Greater than equal operator. cppreference 30.
 
template<typename T >
ETL_CONSTEXPR20_STL etl::optional< typename etl::decay< T >::type > make_optional (T &value)
 Make an optional.
 
template<typename T >
ETL_CONSTEXPR17 etl::enable_if<!etl::is_same< T, etl::nullptr_t >::value, T >::type * addressof (T &t)
 
template<size_t MaxN>
bitset< MaxNoperator& (const bitset< MaxN > &lhs, const bitset< MaxN > &rhs)
 
template<size_t MaxN>
bitset< MaxNoperator| (const bitset< MaxN > &lhs, const bitset< MaxN > &rhs)
 
template<size_t MaxN>
bitset< MaxNoperator^ (const bitset< MaxN > &lhs, const bitset< MaxN > &rhs)
 
template<size_t MaxN>
bool operator!= (const bitset< MaxN > &lhs, const bitset< MaxN > &rhs)
 
template<size_t Active_Bits, typename TElement >
ETL_CONSTEXPR14 bitset< Active_Bits > operator& (const bitset< Active_Bits, TElement > &lhs, const bitset< Active_Bits, TElement > &rhs) ETL_NOEXCEPT
 
template<size_t Active_Bits, typename TElement >
ETL_CONSTEXPR14 bitset< Active_Bits > operator| (const bitset< Active_Bits, TElement > &lhs, const bitset< Active_Bits, TElement > &rhs) ETL_NOEXCEPT
 
template<size_t Active_Bits, typename TElement >
ETL_CONSTEXPR14 bitset< Active_Bits > operator^ (const bitset< Active_Bits, TElement > &lhs, const bitset< Active_Bits, TElement > &rhs) ETL_NOEXCEPT
 
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 T , typename TVariant >
Tget (TVariant &variant)
 
template<typename T , typename TVariant >
T constget (TVariant const &variant)
 
template<size_t tIndex, typename TVariant >
variant_alternative< tIndex, TVariant >::type & get (TVariant &variant)
 
template<size_t tIndex, typename TVariant >
variant_alternative< tIndex, TVariantconst >::type & get (TVariant const &variant)
 
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 deduction guides.
 
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 deduction guides.
 
template<typename T , typename TKeyCompare >
bool operator!= (const etl::ireference_flat_set< T, TKeyCompare > &lhs, const etl::ireference_flat_set< T, TKeyCompare > &rhs)
 
template<uint32_t SCALING, typename T >
T round_ceiling_unscaled (T value)
 
template<uint32_t SCALING, typename T >
T round_ceiling_scaled (T value)
 
template<uint32_t SCALING, typename T >
T round_floor_unscaled (T value)
 
template<uint32_t SCALING, typename T >
T round_floor_scaled (T value)
 
template<uint32_t SCALING, typename T >
T round_half_up_unscaled (T value)
 
template<uint32_t SCALING, typename T >
T round_half_up_scaled (T value)
 
template<uint32_t SCALING, typename T >
T round_half_down_unscaled (T value)
 
template<uint32_t SCALING, typename T >
T round_half_down_scaled (T value)
 
template<uint32_t SCALING, typename T >
T round_zero_unscaled (T value)
 
template<uint32_t SCALING, typename T >
T round_zero_scaled (T value)
 
template<uint32_t SCALING, typename T >
T round_infinity_unscaled (T value)
 
template<uint32_t SCALING, typename T >
T round_infinity_scaled (T value)
 
template<uint32_t SCALING, typename T >
T round_half_even_unscaled (T value)
 
template<uint32_t SCALING, typename T >
T round_half_even_scaled (T value)
 
template<uint32_t SCALING, typename T >
T round_half_odd_unscaled (T value)
 
template<uint32_t SCALING, typename T >
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.
 
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<typename T , size_t Extent>
ETL_CONSTEXPR span< T, Extentmake_span (T(&data)[Extent])
 
template<typename T >
ETL_CONSTEXPR span< typename T::value_type, etl::dynamic_extent > make_span (T &data)
 
template<typename T >
ETL_CONSTEXPR span< typename T::value_type const, etl::dynamic_extent > make_span (const T &data)
 
template<typename T1 , size_t N1, typename T2 , size_t N2>
ETL_NODISCARD ETL_CONSTEXPR etl::enable_if< etl::is_same< typenameetl::remove_cv< T1 >::type, typenameetl::remove_cv< T2 >::type >::value, bool >::type operator== (const etl::span< T1, N1 > &lhs, const etl::span< T2, N2 > &rhs) ETL_NOEXCEPT
 Compare two spans for equality.
 
template<typename T1 , size_t N1, typename T2 , size_t N2>
ETL_NODISCARD ETL_CONSTEXPR bool operator!= (const etl::span< T1, N1 > &lhs, const etl::span< T2, N2 > &rhs) ETL_NOEXCEPT
 Compare two spans for inequality.
 
template<typename T1 , size_t N1, typename T2 , size_t N2>
etl::enable_if< etl::is_same< typenameetl::remove_cv< T1 >::type, typenameetl::remove_cv< T2 >::type >::value, bool >::type equal (const etl::span< T1, N1 > &lhs, const etl::span< T2, N2 > &rhs)
 
template<class T , size_t N>
span< const byte,(N==etl::dynamic_extent) ?(etl::dynamic_extent) :(N *sizeof(T))> as_bytes (span< T, N > s) ETL_NOEXCEPT
 Template deduction guides.
 
template<class T , size_t N>
span< byte,(N==etl::dynamic_extent) ?(etl::dynamic_extent) :(N *sizeof(T))> as_writable_bytes (span< T, N > s) ETL_NOEXCEPT
 Obtains a view to the byte representation of the elements of the span s.
 
template<size_t Array_Size>
etl::string< Array_Size - 1Umake_string (const char(&text)[Array_Size])
 Hash function.
 
template<size_t MAX_SIZE, 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< TStringViewget_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>
ETL_CONSTEXPR14 string_view make_string_view (const char(&text)[Array_Size])
 make_string_view.
 
template<size_t Array_Size>
ETL_CONSTEXPR14 wstring_view make_string_view (const wchar_t(&text)[Array_Size])
 
template<size_t Array_Size>
ETL_CONSTEXPR14 u8string_view make_string_view (const char8_t(&text)[Array_Size])
 
template<size_t Array_Size>
ETL_CONSTEXPR14 u16string_view make_string_view (const char16_t(&text)[Array_Size])
 
template<size_t Array_Size>
ETL_CONSTEXPR14 u32string_view make_string_view (const char32_t(&text)[Array_Size])
 
template<typename TValue , typename TChar >
ETL_NODISCARD ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< TValue >::value, etl::to_arithmetic_result< TValue > >::type to_arithmetic (etl::basic_string_view< TChar > view, const etl::radix::value_type radix)
 Text to integral from view and radix value type.
 
template<typename TValue , typename TChar >
ETL_NODISCARD ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< TValue >::value, etl::to_arithmetic_result< TValue > >::type to_arithmetic (const etl::basic_string_view< TChar > &view)
 Text to integral from view and default decimal radix.
 
template<typename TValue , typename TChar >
ETL_NODISCARD ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< TValue >::value, etl::to_arithmetic_result< TValue > >::type to_arithmetic (const etl::basic_string_view< TChar > &view, const typename etl::private_basic_format_spec::base_spec &spec)
 Text to integral from view and radix format spec.
 
template<typename TValue , typename TChar >
ETL_NODISCARD ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< TValue >::value, etl::to_arithmetic_result< TValue > >::type to_arithmetic (const TChar *cp, size_t length, const etl::radix::value_type radix)
 Text to integral from pointer, length and radix value type.
 
template<typename TValue , typename TChar >
ETL_NODISCARD ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< TValue >::value, etl::to_arithmetic_result< TValue > >::type to_arithmetic (const TChar *cp, size_t length)
 Text to integral from pointer, length and default decimal radix.
 
template<typename TValue , typename TChar >
ETL_NODISCARD ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< TValue >::value, etl::to_arithmetic_result< TValue > >::type to_arithmetic (const TChar *cp, size_t length, const typename etl::private_basic_format_spec::base_spec &spec)
 Text to integral from pointer, length and radix format spec.
 
template<typename TValue , typename TChar >
ETL_NODISCARD ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< TValue >::value, etl::to_arithmetic_result< TValue > >::type to_arithmetic (const etl::ibasic_string< TChar > &str, const etl::radix::value_type radix)
 Text to integral from string and radix value type.
 
template<typename TValue , typename TChar >
ETL_NODISCARD ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< TValue >::value, etl::to_arithmetic_result< TValue > >::type to_arithmetic (const etl::ibasic_string< TChar > &str)
 Text to integral from string and default decimal radix.
 
template<typename TValue , typename TChar >
ETL_NODISCARD ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< TValue >::value, etl::to_arithmetic_result< TValue > >::type to_arithmetic (const etl::ibasic_string< TChar > &str, const typename etl::private_basic_format_spec::base_spec &spec)
 Text to integral from string and radix format spec.
 
template<typename TValue , typename TChar >
ETL_NODISCARD ETL_CONSTEXPR14 etl::enable_if< etl::is_floating_point< TValue >::value, etl::to_arithmetic_result< TValue > >::type to_arithmetic (etl::basic_string_view< TChar > view)
 Floating point from view.
 
template<typename TValue , typename TChar >
ETL_NODISCARD ETL_CONSTEXPR14 etl::enable_if< etl::is_floating_point< TValue >::value, etl::to_arithmetic_result< TValue > >::type to_arithmetic (const TChar *cp, size_t length)
 Floating point from pointer and length.
 
template<typename TValue , typename TChar >
ETL_NODISCARD ETL_CONSTEXPR14 etl::enable_if< etl::is_floating_point< TValue >::value, etl::to_arithmetic_result< TValue > >::type to_arithmetic (const TChar *cp)
 Floating point from pointer.
 
template<typename TValue , typename TChar >
ETL_NODISCARD ETL_CONSTEXPR14 etl::enable_if< etl::is_floating_point< TValue >::value, etl::to_arithmetic_result< TValue > >::type to_arithmetic (const etl::ibasic_string< TChar > &str)
 Floating point from string.
 
template<typename T >
etl::enable_if<!etl::is_same< T, etl::istring >::value &&!etl::is_same< T, etl::string_view >::value, constetl::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, constetl::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 &&!etl::is_same< T, etl::string_view >::value, constetl::istring & >::type to_string (const T value, uint32_t denominator_exponent, 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, constetl::istring & >::type to_string (const T value, uint32_t denominator_exponent, etl::istring &str, const etl::format_spec &format, bool append=false)
 
template<typename T >
etl::enable_if< etl::is_same< T, etl::istring >::value, constetl::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, constetl::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, constetl::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, constetl::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, constetl::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, constetl::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 &&!etl::is_same< T, etl::u16string_view >::value, constetl::iu16string & >::type to_string (const T value, uint32_t denominator_exponent, 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, constetl::iu16string & >::type to_string (const T value, uint32_t denominator_exponent, etl::iu16string &str, const etl::u16format_spec &format, bool append=false)
 
template<typename T >
etl::enable_if< etl::is_same< T, etl::iu16string >::value, constetl::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, constetl::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, constetl::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, constetl::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, constetl::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, constetl::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 &&!etl::is_same< T, etl::u16string_view >::value, constetl::iu32string & >::type to_string (const T value, uint32_t denominator_exponent, etl::iu32string &str, bool append=false)
 
template<typename T >
etl::enable_if<!etl::is_same< T, etl::iu32string >::value &&!etl::is_same< T, etl::u16string_view >::value, constetl::iu32string & >::type to_string (const T value, uint32_t denominator_exponent, etl::iu32string &str, const etl::u32format_spec &format, bool append=false)
 
template<typename T >
etl::enable_if< etl::is_same< T, etl::iu32string >::value, constetl::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, constetl::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, constetl::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, constetl::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::iu8string >::value &&!etl::is_same< T, etl::u8string_view >::value, constetl::iu8string & >::type to_string (const T value, etl::iu8string &str, bool append=false)
 
template<typename T >
etl::enable_if<!etl::is_same< T, etl::iu8string >::value &&!etl::is_same< T, etl::u8string_view >::value, constetl::iu8string & >::type to_string (const T value, etl::iu8string &str, const etl::u8format_spec &format, bool append=false)
 
template<typename T >
etl::enable_if<!etl::is_same< T, etl::iu8string >::value &&!etl::is_same< T, etl::u8string_view >::value, constetl::iu8string & >::type to_string (const T value, uint32_t denominator_exponent, etl::iu8string &str, bool append=false)
 
template<typename T >
etl::enable_if<!etl::is_same< T, etl::iu8string >::value &&!etl::is_same< T, etl::u8string_view >::value, constetl::iu8string & >::type to_string (const T value, uint32_t denominator_exponent, etl::iu8string &str, const etl::u8format_spec &format, bool append=false)
 
template<typename T >
etl::enable_if< etl::is_same< T, etl::iu8string >::value, constetl::iu8string & >::type to_string (const T &value, etl::iu8string &str, bool append=false)
 
template<typename T >
etl::enable_if< etl::is_same< T, etl::iu8string >::value, constetl::iu8string & >::type to_string (const etl::iu8string &value, T &str, const etl::u8format_spec &format, bool append=false)
 
template<typename T >
etl::enable_if< etl::is_same< T, etl::u8string_view >::value, constetl::iu8string & >::type to_string (T value, etl::iu8string &str, bool append=false)
 
template<typename T >
etl::enable_if< etl::is_same< T, etl::u8string_view >::value, constetl::iu8string & >::type to_string (T value, etl::iu8string &str, const etl::u8format_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, constetl::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, constetl::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 &&!etl::is_same< T, etl::u16string_view >::value, constetl::iwstring & >::type to_string (const T value, uint32_t denominator_exponent, etl::iwstring &str, bool append=false)
 
template<typename T >
etl::enable_if<!etl::is_same< T, etl::iwstring >::value &&!etl::is_same< T, etl::u16string_view >::value, constetl::iwstring & >::type to_string (const T value, uint32_t denominator_exponent, etl::iwstring &str, const etl::wformat_spec &format, bool append=false)
 
template<typename T >
etl::enable_if< etl::is_same< T, etl::iwstring >::value, constetl::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, constetl::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, constetl::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, constetl::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 - 1Umake_string (const char16_t(&text)[Array_Size])
 Hash function.
 
template<size_t MAX_SIZE, 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 - 1Umake_string (const char32_t(&text)[Array_Size])
 Hash function.
 
template<size_t MAX_SIZE, 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<size_t Array_Size>
etl::u8string< Array_Size - 1Umake_string (const char(&text)[Array_Size])
 Hash function.
 
template<size_t MAX_SIZE, size_t SIZE>
etl::u8string< MAX_SIZE > make_string_with_capacity (const char(&text)[SIZE])
 Make u8string with max capacity from u8string literal or array.
 
template<typename TKey , typename T , typename THash , typename TKeyEqual >
bool operator== (const etl::iunordered_map< TKey, T, THash, TKeyEqual > &lhs, const etl::iunordered_map< TKey, T, THash, TKeyEqual > &rhs)
 
template<typename TKey , typename T , typename THash , typename TKeyEqual >
bool operator!= (const etl::iunordered_map< TKey, T, THash, TKeyEqual > &lhs, const etl::iunordered_map< TKey, T, THash, TKeyEqual > &rhs)
 
template<typename TKey , typename T , typename THash , typename TKeyEqual >
bool operator== (const etl::iunordered_multimap< TKey, T, THash, TKeyEqual > &lhs, const etl::iunordered_multimap< TKey, T, THash, TKeyEqual > &rhs)
 
template<typename TKey , typename T , typename THash , typename TKeyEqual >
bool operator!= (const etl::iunordered_multimap< TKey, T, THash, TKeyEqual > &lhs, const etl::iunordered_multimap< TKey, T, THash, TKeyEqual > &rhs)
 
template<typename TKey , typename THash , typename TKeyEqual >
bool operator== (const etl::iunordered_multiset< TKey, THash, TKeyEqual > &lhs, const etl::iunordered_multiset< TKey, THash, TKeyEqual > &rhs)
 
template<typename TKey , typename THash , typename TKeyEqual >
bool operator!= (const etl::iunordered_multiset< TKey, THash, TKeyEqual > &lhs, const etl::iunordered_multiset< TKey, THash, TKeyEqual > &rhs)
 
template<typename TKey , typename THash , typename TKeyEqual >
bool operator== (const etl::iunordered_set< TKey, THash, TKeyEqual > &lhs, const etl::iunordered_set< TKey, THash, TKeyEqual > &rhs)
 
template<typename TKey , typename THash , typename TKeyEqual >
bool operator!= (const etl::iunordered_set< TKey, THash, TKeyEqual > &lhs, const etl::iunordered_set< TKey, THash, TKeyEqual > &rhs)
 
template<typename T1 , typename T2 >
pair< T1, T2make_pair (T1 a, T2 b)
 A convenience wrapper for creating a pair from two objects.
 
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)
 Two pairs of the same type are equal iff their members are equal.
 
template<typename T1 , typename T2 >
bool operator!= (const pair< T1, T2 > &a, const pair< T1, T2 > &b)
 Uses operator== to find the result.
 
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)
 Uses operator< to find the result.
 
template<typename T1 , typename T2 >
bool operator<= (const pair< T1, T2 > &a, const pair< T1, T2 > &b)
 Uses operator< to find the result.
 
template<typename T1 , typename T2 >
bool operator>= (const pair< T1, T2 > &a, const pair< T1, T2 > &b)
 Uses operator< to find the result.
 
template<typename T >
T exchange (T &object, const T &new_value)
 exchange (const)
 
template<typename T , typename U >
T 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 - 1Umake_string (const wchar_t(&text)[Array_Size])
 Hash function.
 
template<size_t MAX_SIZE, 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 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

bitset_ext

A multimap with the capacity defined at compile time.

A multiset with the capacity defined at compile time.

‍******************************************************************************

A wrapper for reference counted messages. Contains pointers to a pool owner and a message defined with a ref count type.

Function Documentation

◆ array_size()

template<typename T , size_t Array_Size>
char(& etl::array_size ( T(&)  array[Array_Size]) )[Array_Size]

Get the size of an array in elements at compile time for C++03

sizeof(array_size(array))
Definition array.h:88
char(& array_size(T(&array)[Array_Size]))[Array_Size]

◆ as_bytes()

template<class T , size_t N>
span< const byte,(N==etl::dynamic_extent) ?(etl::dynamic_extent) :(N *sizeof(T))> etl::as_bytes ( span< T, N s)

Template deduction guides.

Hash function. Obtains a view to the byte representation of the elements of the span s.

◆ begin() [1/4]

template<typename TContainer >
ETL_CONSTEXPR TContainer::const_iterator etl::begin ( const TContainer container)

Get the 'begin' const_iterator for a container.

◆ begin() [2/4]

template<typename TValue , size_t Array_Size>
ETL_CONSTEXPR const TValue * etl::begin ( const TValue(&)  data[Array_Size])

Get the 'begin' const iterator for an array.

◆ begin() [3/4]

template<typename TContainer >
ETL_CONSTEXPR TContainer::iterator etl::begin ( TContainer container)

Get the 'begin' iterator.

◆ begin() [4/4]

template<typename TValue , size_t Array_Size>
ETL_CONSTEXPR TValue * etl::begin ( TValue(&)  data[Array_Size])

Get the 'begin' pointer for an array.

◆ binary_interleave() [1/2]

template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_unsigned< T >::value &&(etl::integral_limits< T >::bits==32U), uint64_t >::type etl::binary_interleave ( T  first,
T  second 
)

Binary interleave

◆ binary_interleave() [2/2]

template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_signed< T >::value, T >::type etl::binary_interleave ( T  first,
T  second 
)

Binary interleave for signed

◆ cbegin() [1/2]

template<typename TContainer >
ETL_CONSTEXPR TContainer::const_iterator etl::cbegin ( const TContainer container)

Get the 'begin' const_iterator for a container.

◆ cbegin() [2/2]

template<typename TValue , size_t Array_Size>
ETL_CONSTEXPR const TValue * etl::cbegin ( const TValue(&)  data[Array_Size])

Get the 'begin' const iterator for an array.

◆ cend() [1/2]

template<typename TContainer >
ETL_CONSTEXPR TContainer::const_iterator etl::cend ( const TContainer container)

Get the 'end' const_iterator for a container.

◆ cend() [2/2]

template<typename TValue , size_t Array_Size>
ETL_CONSTEXPR const TValue * etl::cend ( const TValue(&)  data[Array_Size])

Get the 'end' const iterator for an array.

◆ copy_s()

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.

◆ count_bits() [1/3]

template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_unsigned< T >::value &&(etl::integral_limits< T >::bits==32U), uint_least8_t >::type etl::count_bits ( T  value)

Count set bits. 32 bits.

◆ count_bits() [2/3]

template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_unsigned< T >::value &&(etl::integral_limits< T >::bits==64U), uint_least8_t >::type etl::count_bits ( T  value)

Count set bits. 64 bits.

◆ count_bits() [3/3]

template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_signed< T >::value, uint_least8_t >::type etl::count_bits ( T  value)

Count set bits for signed.

◆ count_leading_ones() [1/3]

template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_unsigned< T >::value &&(etl::integral_limits< T >::bits==32U), uint_least8_t >::type etl::count_leading_ones ( T  value)

Count leading ones. Uses a binary search.

◆ count_leading_ones() [2/3]

template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_unsigned< T >::value &&(etl::integral_limits< T >::bits==64U), uint_least8_t >::type etl::count_leading_ones ( T  value)

Count leading ones. Uses a binary search.

◆ count_leading_ones() [3/3]

template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_signed< T >::value, uint_least8_t >::type etl::count_leading_ones ( T  value)

Count leading ones for signed.

◆ count_leading_zeros() [1/3]

template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_unsigned< T >::value &&(etl::integral_limits< T >::bits==32U), uint_least8_t >::type etl::count_leading_zeros ( T  value)

Count leading zeros. Uses a binary search.

◆ count_leading_zeros() [2/3]

template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_unsigned< T >::value &&(etl::integral_limits< T >::bits==64U), uint_least8_t >::type etl::count_leading_zeros ( T  value)

Count leading zeros. Uses a binary search.

◆ count_leading_zeros() [3/3]

template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_signed< T >::value, uint_least8_t >::type etl::count_leading_zeros ( T  value)

Count leading zeros for signed.

◆ count_trailing_ones() [1/3]

template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_unsigned< T >::value &&(etl::integral_limits< T >::bits==32U), uint_least8_t >::type etl::count_trailing_ones ( T  value)

Count trailing zeros. 32bit. Uses a binary search.

◆ count_trailing_ones() [2/3]

template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_unsigned< T >::value &&(etl::integral_limits< T >::bits==64U), uint_least8_t >::type etl::count_trailing_ones ( T  value)

Count trailing zeros. 64bit. Uses a binary search.

◆ count_trailing_ones() [3/3]

template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_signed< T >::value, uint_least8_t >::type etl::count_trailing_ones ( T  value)

Count trailing ones for signed.

◆ count_trailing_zeros() [1/3]

template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_unsigned< T >::value &&(etl::integral_limits< T >::bits==32U), uint_least8_t >::type etl::count_trailing_zeros ( T  value)

Count trailing zeros. 32bit. Uses a binary search.

◆ count_trailing_zeros() [2/3]

template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_unsigned< T >::value &&(etl::integral_limits< T >::bits==64U), uint_least8_t >::type etl::count_trailing_zeros ( T  value)

Count trailing zeros. 64bit. Uses a binary search.

◆ count_trailing_zeros() [3/3]

template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_signed< T >::value, uint_least8_t >::type etl::count_trailing_zeros ( T  value)

Count trailing zeros for signed.

◆ crbegin() [1/2]

template<typename TContainer >
ETL_CONSTEXPR TContainer::const_reverse_iterator etl::crbegin ( const TContainer container)

Get the 'begin' reverse_iterator for a container.

◆ crbegin() [2/2]

template<typename TValue , size_t Array_Size>
ETL_CONSTEXPR ETL_OR_STD::reverse_iterator< const TValue * > etl::crbegin ( const TValue(&)  data[Array_Size])

Get the 'begin' const reverse_iterator for an array.

◆ crend() [1/2]

template<typename TContainer >
ETL_CONSTEXPR TContainer::const_reverse_iterator etl::crend ( const TContainer container)

Get the 'end' reverse_iterator for a container.

◆ crend() [2/2]

template<typename TValue , size_t Array_Size>
ETL_CONSTEXPR ETL_OR_STD::reverse_iterator< const TValue * > etl::crend ( const TValue(&)  data[Array_Size])

Get the 'end' const reverse_iterator for an array.

◆ destroy() [1/2]

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

◆ destroy() [2/2]

etl::enable_if<!etl::is_trivially_destructible< typenameetl::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]

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

◆ destroy_n() [2/2]

etl::enable_if<!etl::is_trivially_destructible< typenameetl::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

◆ end() [1/4]

template<typename TContainer >
ETL_CONSTEXPR TContainer::const_iterator etl::end ( const TContainer container)

Get the 'end' const_iterator for a container.

◆ end() [2/4]

template<typename TValue , size_t Array_Size>
ETL_CONSTEXPR const TValue * etl::end ( const TValue(&)  data[Array_Size])

Get the 'end' const iterator for an array.

◆ end() [3/4]

template<typename TContainer >
ETL_CONSTEXPR TContainer::iterator etl::end ( TContainer container)

Get the 'end' iterator for a container.

◆ end() [4/4]

template<typename TValue , size_t Array_Size>
ETL_CONSTEXPR TValue * etl::end ( TValue(&)  data[Array_Size])

Get the 'end' iterator for an array.

◆ equal()

template<typename T1 , size_t N1, typename T2 , size_t N2>
etl::enable_if< etl::is_same< typenameetl::remove_cv< T1 >::type, typenameetl::remove_cv< T2 >::type >::value, bool >::type etl::equal ( const etl::span< T1, N1 > &  lhs,
const etl::span< T2, N2 > &  rhs 
)

Equality function. Performs a comparison of the range values. Returns true if one of the following are true

  1. Both spans are empty.
  2. They both point to the same range of data.
  3. The values in the two ranges are equal.

◆ 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

◆ gray_to_binary() [1/3]

template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_unsigned< T >::value &&(etl::integral_limits< T >::bits==32U), T >::type etl::gray_to_binary ( T  value)

Converts Gray code to binary.

◆ gray_to_binary() [2/3]

template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_unsigned< T >::value &&(etl::integral_limits< T >::bits==64U), T >::type etl::gray_to_binary ( T  value)

Converts Gray code to binary.

◆ gray_to_binary() [3/3]

template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_signed< T >::value, T >::type etl::gray_to_binary ( T  value)

Converts Gray code to binary for signed.

◆ is_aligned()

template<size_t Alignment>
bool etl::is_aligned ( void p)

Check that 'p' has 'Alignment'.

Check that 'p' has the alignment of 'T'.

◆ lerp() [1/2]

template<typename T >
ETL_CONSTEXPR etl::enable_if< etl::is_floating_point< T >::value, T >::type etl::lerp ( T  a,
T  b,
T  t 
)

Linear interpolation For floating point.

◆ lerp() [2/2]

Linear interpolation For when any parameter is not floating point.

◆ make_pair()

template<typename T1 , typename T2 >
pair< T1, T2 > etl::make_pair ( T1  a,
T2  b 
)
inline

A convenience wrapper for creating a pair from two objects.

Parameters
aThe first object.
bThe second object.
Returns
A newly-constructed pair object of the appropriate type.

◆ make_span() [1/3]

template<typename T >
ETL_CONSTEXPR span< typename T::value_type const, etl::dynamic_extent > etl::make_span ( const T data)

Pseudo constructor for constructing from const container without explicitly specifying type and size

◆ make_span() [2/3]

template<typename T >
ETL_CONSTEXPR span< typename T::value_type, etl::dynamic_extent > etl::make_span ( T data)

Pseudo constructor for constructing from container without explicitly specifying type and size

◆ make_span() [3/3]

template<typename T , size_t Extent>
ETL_CONSTEXPR span< T, Extent > etl::make_span ( T(&)  data[Extent])

Pseudo constructor for constructing from C array without explicitly specifying type and size

◆ make_string() [1/5]

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

Hash function.

Make string from string literal or array

◆ make_string() [2/5]

template<size_t Array_Size>
etl::u8string< Array_Size - 1U > etl::make_string ( const char(&)  text[Array_Size])

Hash function.

Make u8string from u8string literal or array

◆ make_string() [3/5]

template<size_t Array_Size>
etl::u16string< Array_Size - 1U > etl::make_string ( const char16_t(&)  text[Array_Size])

Hash function.

Make string from string literal or array

◆ make_string() [4/5]

template<size_t Array_Size>
etl::u32string< Array_Size - 1U > etl::make_string ( const char32_t(&)  text[Array_Size])

Hash function.

Make string from string literal or array

◆ make_string() [5/5]

template<size_t Array_Size>
etl::wstring< Array_Size - 1U > etl::make_string ( const wchar_t(&)  text[Array_Size])

Hash function.

Make string from string literal or array

◆ midpoint() [1/6]

template<typename T >
ETL_CONSTEXPR14 etl::enable_if<!etl::is_pointer< T >::value &&!etl::is_integral< T >::value &&etl::is_floating_point< T >::value, T >::type etl::midpoint ( T  a,
T  b 
)

midpoint For floating point.

◆ midpoint() [2/6]

template<typename T >
ETL_CONSTEXPR14 etl::enable_if<!etl::is_pointer< T >::value &&etl::is_integral< T >::value &&!etl::is_floating_point< T >::value &&etl::is_unsigned< T >::value, T >::type etl::midpoint ( T  a,
T  b 
)

midpoint For unsigned integrals.

◆ midpoint() [3/6]

template<typename T >
ETL_CONSTEXPR14 etl::enable_if<!etl::is_pointer< T >::value &&etl::is_integral< T >::value &&!etl::is_floating_point< T >::value &&etl::is_signed< T >::value, T >::type etl::midpoint ( T  a,
T  b 
)

midpoint For signed integrals.

◆ midpoint() [4/6]

template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_pointer< T >::value &&!etl::is_integral< T >::value &&!etl::is_floating_point< T >::value, T >::type etl::midpoint ( T  a,
T  b 
)

midpoint For pointers.

◆ midpoint() [5/6]

template<typename T >
ETL_CONSTEXPR14 T etl::midpoint ( T  a,
T  b,
typename etl::enable_if<!etl::is_pointer< T >::value &&!etl::is_integral< T >::value &&!etl::is_floating_point< T >::value &&etl::is_same< typename etl::iterator_traits< T >::iterator_category, ETL_OR_STD::random_access_iterator_tag >::value, int >::type  = 0 
)

midpoint For ETL random access iterators.

◆ midpoint() [6/6]

template<typename T >
ETL_CONSTEXPR14 T etl::midpoint ( T  a,
T  b,
typename etl::enable_if<(!etl::is_pointer< T >::value &&!etl::is_integral< T >::value &&!etl::is_floating_point< T >::value &&(etl::is_same< typename etl::iterator_traits< T >::iterator_category, ETL_OR_STD::forward_iterator_tag >::value||etl::is_same< typename etl::iterator_traits< T >::iterator_category, ETL_OR_STD::bidirectional_iterator_tag >::value)), int >::type  = 0 
)

midpoint For ETL forward and bidirectional iterators. Parameter 'a' must be before 'b', otherwise the result is undefined.

◆ nth_element()

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

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]

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]

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]

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]

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]

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]

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+() [1/2]

template<typename TIterator >
ETL_CONSTEXPR14 etl::circular_iterator< TIterator > etl::operator+ ( etl::circular_iterator< TIterator > &  lhs,
typename etl::iterator_traits< TIterator >::difference_type  offset 
)
  • addition operator.

◆ operator+() [2/2]

  • difference operator.

◆ operator-() [1/4]

◆ operator-() [2/4]

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

◆ operator-() [3/4]

template<typename TIterator >
ETL_CONSTEXPR14 etl::circular_iterator< TIterator > etl::operator- ( etl::circular_iterator< TIterator > &  lhs,
typename etl::iterator_traits< TIterator >::difference_type  offset 
)
  • offset operator.

◆ operator-() [4/4]

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

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]

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]

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]

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]

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]

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]

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]

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 deduction guides.

Make 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 deduction guides.

Make 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 deduction guides.

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

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 deduction guides.

Make 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 deduction guides.

Make 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 deduction guides.

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

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]

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]

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]

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]

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]

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]

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]

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

◆ parity() [1/3]

template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_unsigned< T >::value &&(etl::integral_limits< T >::bits==32U), uint_least8_t >::type etl::parity ( T  value)

Parity. 32bits. 0 = even, 1 = odd

◆ parity() [2/3]

template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_unsigned< T >::value &&(etl::integral_limits< T >::bits==64U), uint_least8_t >::type etl::parity ( T  value)

Parity. 64bits. 0 = even, 1 = odd

◆ parity() [3/3]

template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_signed< T >::value, uint_least8_t >::type etl::parity ( T  value)

Parity for signed.

◆ partition() [1/2]

ETL_CONSTEXPR14 etl::enable_if< etl::is_forward_iterator< TIterator >::value, TIterator >::type etl::partition ( TIterator  first,
TIterator  last,
TPredicate  predicate 
)

Returns the maximum value.

Returns the maximum value. User supplied compare function. Returns the maximum value. Returns the minimum value. User supplied compare function. Returns the iterator to the maximum value. Returns the iterator to the maximum value. User supplied compare function. Returns the iterator to the minimum value. Returns the iterator to the minimum value. User supplied compare function. partition For forward iterators only Does at most etl::distance(first, last) swaps.

◆ partition() [2/2]

ETL_CONSTEXPR14 etl::enable_if< etl::is_bidirectional_iterator_concept< TIterator >::value, TIterator >::type etl::partition ( TIterator  first,
TIterator  last,
TPredicate  predicate 
)

partition For iterators that support bidirectional iteration. Does at most (etl::distance(first, last) / 2) swaps.

◆ rbegin() [1/3]

template<typename TContainer >
ETL_CONSTEXPR TContainer::const_reverse_iterator etl::rbegin ( const TContainer container)

Get the 'begin' reverse_iterator for a container.

◆ rbegin() [2/3]

template<typename TContainer >
ETL_CONSTEXPR TContainer::reverse_iterator etl::rbegin ( TContainer container)

Get the 'begin' reverse_iterator for a container.

◆ rbegin() [3/3]

template<typename TValue , size_t Array_Size>
ETL_OR_STD::reverse_iterator< TValue * > etl::rbegin ( TValue(&)  data[Array_Size])

Get the 'begin' reverse_iterator for an array.

◆ read_unchecked()

template<typename T >
T etl::read_unchecked ( etl::byte_stream_reader stream)

Default implementation of the read function. For integral and floating point types only. Overload this to support custom types.

◆ rend() [1/3]

template<typename TContainer >
ETL_CONSTEXPR TContainer::const_reverse_iterator etl::rend ( const TContainer container)

Get the 'end' reverse_iterator for a container.

◆ rend() [2/3]

template<typename TContainer >
ETL_CONSTEXPR TContainer::reverse_iterator etl::rend ( TContainer container)

Get the 'end' reverse_iterator for a container.

◆ rend() [3/3]

template<typename TValue , size_t Array_Size>
ETL_CONSTEXPR ETL_OR_STD::reverse_iterator< TValue * > etl::rend ( TValue(&)  data[Array_Size])

Get the 'end' reverse_iterator for an array.

◆ reverse()

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

reverse Reverse a string

◆ reverse_bits() [1/3]

template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_unsigned< T >::value &&(etl::integral_limits< T >::bits==32U), T >::type etl::reverse_bits ( T  value)

Reverse 32 bits.

◆ reverse_bits() [2/3]

template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_unsigned< T >::value &&(etl::integral_limits< T >::bits==64U), T >::type etl::reverse_bits ( T  value)

Reverse 64 bits.

◆ reverse_bits() [3/3]

template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_signed< T >::value, T >::type etl::reverse_bits ( T  value)

Reverse bits signed types.

◆ reverse_bytes() [1/3]

template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_unsigned< T >::value &&(etl::integral_limits< T >::bits==32U), T >::type etl::reverse_bytes ( T  value)

Reverse bytes 32 bit.

◆ reverse_bytes() [2/3]

template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_unsigned< T >::value &&(etl::integral_limits< T >::bits==64U), T >::type etl::reverse_bytes ( T  value)

Reverse bytes 64 bit.

◆ reverse_bytes() [3/3]

template<typename T >
ETL_CONSTEXPR14 etl::enable_if< etl::is_integral< T >::value &&etl::is_signed< T >::value, T >::type etl::reverse_bytes ( T  value)

Reverse bytes signed types.

◆ round_ceiling_scaled()

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

Round to more positive integer.

Parameters
valueScaled integral.
Returns
Scaled, rounded integral.

◆ round_ceiling_unscaled()

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

Round to more positive integer.

Parameters
valueScaled integral.
Returns
Unscaled, rounded integral.

◆ round_floor_scaled()

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

Round to more negative integer.

Parameters
valueScaled integral.
Returns
Scaled, rounded integral.

◆ round_floor_unscaled()

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

Round to more negative integer.

Parameters
valueScaled integral.
Returns
Unscaled, rounded integral.

◆ round_half_down_scaled()

template<uint32_t SCALING, typename T >
T etl::round_half_down_scaled ( T  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<uint32_t SCALING, typename T >
T etl::round_half_down_unscaled ( T  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<uint32_t SCALING, typename T >
T etl::round_half_even_scaled ( T  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<uint32_t SCALING, typename T >
T etl::round_half_even_unscaled ( T  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.

◆ round_half_odd_scaled()

template<uint32_t SCALING, typename T >
T etl::round_half_odd_scaled ( T  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<uint32_t SCALING, typename T >
T etl::round_half_odd_unscaled ( T  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<uint32_t SCALING, typename T >
T etl::round_half_up_scaled ( T  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<uint32_t SCALING, typename T >
T etl::round_half_up_unscaled ( T  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<uint32_t SCALING, typename T >
T etl::round_infinity_scaled ( T  value)

Round toward infinity.

Parameters
valueScaled integral.
Returns
Scaled, rounded integral.

◆ round_infinity_unscaled()

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

Round toward infinity.

Parameters
valueScaled integral.
Returns
Unscaled, rounded integral.

◆ round_zero_scaled()

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

Round toward zero.

Parameters
valueScaled integral.
Returns
Scaled, rounded integral.

◆ round_zero_unscaled()

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

Round toward zero.

Parameters
valueScaled integral.
Returns
Unscaled, rounded integral.

◆ size()

template<typename TContainer >
ETL_CONSTEXPR TContainer::size_type etl::size ( const TContainer container)

Get the size of a container. Expects the container to have defined 'size_type'.

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

Make 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_address() [1/2]

template<typename Iterator >
ETL_CONSTEXPR Iterator::pointer etl::to_address ( const Iterator itr)

Obtain the address represented by itr without forming a reference to the object pointed to by itr. Requires that the iterator defines operator->() Defined when not using the STL or C++20

◆ to_address() [2/2]

template<typename T >
ETL_CONSTEXPR T * etl::to_address ( T p)

Obtain the address represented by p without forming a reference to the object pointed to by p. Defined when not using the STL or C++20

◆ to_string() [1/40]

template<typename T >
etl::enable_if< etl::is_same< T, etl::istring >::value, constetl::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/40]

template<typename T >
etl::enable_if< etl::is_same< T, etl::iu16string >::value, constetl::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/40]

template<typename T >
etl::enable_if< etl::is_same< T, etl::iu32string >::value, constetl::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/40]

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

Supplied format spec. etl::iu8string

◆ to_string() [5/40]

template<typename T >
etl::enable_if< etl::is_same< T, etl::iwstring >::value, constetl::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() [6/40]

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

Default format spec. etl::istring

◆ to_string() [7/40]

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

Default format spec. etl::iu16string

◆ to_string() [8/40]

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

Default format spec. etl::iu32string

◆ to_string() [9/40]

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

Default format spec. etl::iu8string

◆ to_string() [10/40]

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

Default format spec. etl::iwstring

◆ to_string() [11/40]

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

Default format spec. !etlistring && !etlstring_view

◆ to_string() [12/40]

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

Supplied format spec. !etlistring && !etlstring_view

◆ to_string() [13/40]

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

Default format spec. !etliu16string && !etlu16string_view

◆ to_string() [14/40]

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

Supplied format spec. !etliu16string && !etlu16string_view

◆ to_string() [15/40]

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

Default format spec. !etliu32string && !etlu32string_view

◆ to_string() [16/40]

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

Supplied format spec. !etliu32string && !etlu32string_view

◆ to_string() [17/40]

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

Default format spec. !etliu8string && !etlu8string_view

◆ to_string() [18/40]

template<typename T >
etl::enable_if<!etl::is_same< T, etl::iu8string >::value &&!etl::is_same< T, etl::u8string_view >::value, constetl::iu8string & >::type etl::to_string ( const T  value,
etl::iu8string str,
const etl::u8format_spec format,
bool  append = false 
)

Supplied format spec. !etliu8string && !etlu8string_view

◆ to_string() [19/40]

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

Default format spec. !etliwstring && !etlwstring_view

◆ to_string() [20/40]

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

Supplied format spec. !etliwstring && !etlwstring_view

◆ to_string() [21/40]

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

Default format spec. !etlistring && !etlstring_view

◆ to_string() [22/40]

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

Supplied format spec. !etlistring && !etlstring_view

◆ to_string() [23/40]

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

Default format spec. !etliu16string && !etlu16string_view

◆ to_string() [24/40]

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

Supplied format spec. !etlu16string_view && !etlu16string_view

◆ to_string() [25/40]

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

Default format spec. !etliu32string && !etlu16string_view

◆ to_string() [26/40]

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

Supplied format spec. !etlu16string_view && !etlu16string_view

◆ to_string() [27/40]

template<typename T >
etl::enable_if<!etl::is_same< T, etl::iu8string >::value &&!etl::is_same< T, etl::u8string_view >::value, constetl::iu8string & >::type etl::to_string ( const T  value,
uint32_t  denominator_exponent,
etl::iu8string str,
bool  append = false 
)

Default format spec. !etliu8string && !etlu8string_view

◆ to_string() [28/40]

template<typename T >
etl::enable_if<!etl::is_same< T, etl::iu8string >::value &&!etl::is_same< T, etl::u8string_view >::value, constetl::iu8string & >::type etl::to_string ( const T  value,
uint32_t  denominator_exponent,
etl::iu8string str,
const etl::u8format_spec format,
bool  append = false 
)

Supplied format spec. !etlu8string_view && !etlu8string_view

◆ to_string() [29/40]

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

Default format spec. !etliu32string && !etlu16string_view

◆ to_string() [30/40]

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

Supplied format spec. !etlu16string_view && !etlu16string_view

◆ to_string() [31/40]

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

Default format spec. etl::string_view

◆ to_string() [32/40]

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

Supplied format spec. etl::string_view

◆ to_string() [33/40]

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

Default format spec. etl::u16string_view

◆ to_string() [34/40]

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

Supplied format spec. etl::u16string_view

◆ to_string() [35/40]

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

Default format spec. etl::u32string_view

◆ to_string() [36/40]

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

Supplied format spec. etl::u32string_view

◆ to_string() [37/40]

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

Default format spec. etl::u8string_view

◆ to_string() [38/40]

template<typename T >
etl::enable_if< etl::is_same< T, etl::u8string_view >::value, constetl::iu8string & >::type etl::to_string ( T  value,
etl::iu8string str,
const etl::u8format_spec format,
bool  append = false 
)

Supplied format spec. etl::u8string_view

◆ to_string() [39/40]

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

Default format spec. etl::wstring_view

◆ to_string() [40/40]

template<typename T >
etl::enable_if< etl::is_same< T, etl::wstring_view >::value, constetl::iwstring & >::type etl::to_string ( T  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 from right of whitespace

◆ uninitialized_default_construct() [1/2]

etl::enable_if<!etl::is_trivially_constructible< typenameetl::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]

etl::enable_if<!etl::is_trivially_constructible< typenameetl::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]

etl::enable_if<!etl::is_trivially_constructible< typenameetl::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]

etl::enable_if<!etl::is_trivially_constructible< typenameetl::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()

etl::enable_if<!etl::is_trivially_constructible< typenameetl::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

◆ write() [1/2]

bool etl::write ( etl::bit_stream_writer stream,
bool  value 
)
inline

Implementation of the write function. For bool types only.

◆ write() [2/2]

template<typename T >
etl::enable_if< etl::is_integral< T >::value, bool >::type etl::write ( etl::bit_stream_writer stream,
const T value,
uint_least8_t  nbits = CHAR_BIT * sizeof(T) 
)

Default implementation of the write function. For integral types only (but not bool). Overload this to support custom types.

◆ write_unchecked() [1/3]

void etl::write_unchecked ( etl::bit_stream_writer stream,
bool  value 
)
inline

Implementation of the write function. For bool types only.

◆ write_unchecked() [2/3]

template<typename T >
etl::enable_if< etl::is_integral< T >::value, void >::type etl::write_unchecked ( etl::bit_stream_writer stream,
const T value,
uint_least8_t  nbits = CHAR_BIT * sizeof(T) 
)

Default implementation of the write function. For integral types only (but not bool). Overload this to support custom types.

◆ write_unchecked() [3/3]

template<typename T >
void etl::write_unchecked ( etl::byte_stream_writer stream,
const T value 
)

Default implementation of the write function. For integral and floating point types only. Overload this to support custom types.

Variable Documentation

◆ nullopt

const nullopt_t etl::nullopt = {}

A null option.