class inline_vector<T, N> expressions¶

using size_type        = size_t

using stored_size_type = std::conditional_t<(N >= UINT16_MAX), uint32_t,
                                            std::conditional_t<(N >= UINT8_MAX), uint16_t, uint8_t>>

using value_type       = T

using pointer          = T*

using const_pointer    = const T*

using reference        = T&

using const_reference  = const T&

using iterator         = pointer

using const_iterator   = const_pointer

constexpr inline_vector() noexcept : m_size(0) { … }

constexpr inline_vector(const inline_vector&) noexcept            = default

constexpr inline_vector(inline_vector&&) noexcept                 = default

constexpr inline_vector& operator=(const inline_vector&) noexcept = default

constexpr inline_vector& operator=(inline_vector&&) noexcept      = default

constexpr inline_vector(size_type initial_size) : m_size(initial_size) { … }

constexpr inline_vector(size_type initial_size, T initial_value) : m_size(initial_size) { … }

constexpr inline_vector(std::initializer_list<T> list) : inline_vector(list.begin(), list.end()) { … }

template <typename Iter>
constexpr inline_vector(Iter first, Iter last) { … }

constexpr const_reference at(size_type index) const { … }

constexpr reference at(size_type index) { … }

constexpr const_reference operator[](size_type index) const noexcept { … }

constexpr reference operator[](size_type index) noexcept { … }

constexpr size_type size() const noexcept { … }

constexpr pointer data() noexcept { … }

constexpr const_pointer data() const noexcept { … }

constexpr bool empty() const noexcept { … }

constexpr iterator begin() noexcept { … }

constexpr iterator end() noexcept { … }

constexpr const_iterator begin() const noexcept { … }

constexpr const_iterator end() const noexcept { … }

constexpr const_iterator cbegin() const noexcept { … }

constexpr const_iterator cend() const noexcept { … }

constexpr reference front() noexcept { … }

constexpr reference back() noexcept { … }

constexpr const_reference front() const noexcept { … }

constexpr const_reference back() const noexcept { … }

constexpr void push_back(T value) { … }

constexpr bool operator==(const inline_vector& other) const { … }

constexpr bool operator!=(const inline_vector& other) const { … }

T m_values[N]

stored_size_type m_size