static_vector.hpp

Go to the documentation of this file.

// Copyright (c) 2025 Contributors to the Eclipse Foundation
//
// See the NOTICE file(s) distributed with this work for additional
// information regarding copyright ownership.
//
// This program and the accompanying materials are made available under the
// terms of the Apache Software License 2.0 which is available at
// https://www.apache.org/licenses/LICENSE-2.0, or the MIT license
// which is available at https://opensource.org/licenses/MIT.
//
// SPDX-License-Identifier: Apache-2.0 OR MIT
 
#ifndef IOX2_INCLUDE_GUARD_BB_STATIC_VECTOR_HPP
#define IOX2_INCLUDE_GUARD_BB_STATIC_VECTOR_HPP
 
#include "iox2/bb/detail/attributes.hpp"
#include "iox2/bb/optional.hpp"
 
#include "iox2/bb/detail/raw_byte_storage.hpp"
 
#include <algorithm>
#include <cstddef>
#include <cstdint>
#include <cstring>
#include <functional>
#include <initializer_list>
#include <ostream>
#include <type_traits>
 
namespace iox2 {
namespace bb {
 
template <typename T, uint64_t Capacity>
class StaticVector {
    static_assert(Capacity > 0, "Static container with capacity 0 is not allowed.");
    static_assert(std::is_standard_layout<T>::value, "Containers can only be used with standard layout types.");
 
  public:
    using ValueType = T;
    using SizeType = size_t;
    using DifferenceType = ptrdiff_t;
    using Reference = T&;
    using ConstReference = T const&;
    using Pointer = T*;
    using ConstPointer = T const*;
    using Iterator = Pointer;
    using ConstIterator = ConstPointer;
    using OptionalReference = bb::Optional<std::reference_wrapper<T>>;
    using OptionalConstReference = bb::Optional<std::reference_wrapper<T const>>;
 
    class UncheckedConstAccessor {
        friend class StaticVector;
 
      private:
        StaticVector const* m_parent;
 
        constexpr explicit UncheckedConstAccessor(StaticVector const& parent)
            : m_parent(&parent) {
        }
 
      public:
        ~UncheckedConstAccessor() = default;
        UncheckedConstAccessor(UncheckedConstAccessor const&) = delete;
        // NOTE: can be changed to '= delete' when C++17 becomes mandatory and we can rely on RVO
        UncheckedConstAccessor(UncheckedConstAccessor&&) = default;
        auto operator=(UncheckedConstAccessor const&) -> UncheckedConstAccessor& = delete;
        auto operator=(UncheckedConstAccessor&&) -> UncheckedConstAccessor& = delete;
 
        constexpr auto operator[](SizeType index) const&& -> ConstReference {
            return *m_parent->m_storage.pointer_from_index(index);
        }
 
        constexpr auto begin() const&& noexcept -> ConstIterator {
            return m_parent->m_storage.pointer_from_index(0);
        }
 
        constexpr auto end() const&& noexcept -> ConstIterator {
            return m_parent->m_storage.pointer_from_index(m_parent->m_storage.size());
        }
 
        constexpr auto data() const&& noexcept -> ConstPointer {
            return m_parent->m_storage.pointer_from_index(0);
        }
    };
 
    // Mutable unchecked element access.
    class UncheckedAccessor {
        friend class StaticVector;
 
      private:
        StaticVector* m_parent;
 
        constexpr explicit UncheckedAccessor(StaticVector& parent)
            : m_parent(&parent) {
        }
 
      public:
        ~UncheckedAccessor() = default;
        UncheckedAccessor(UncheckedAccessor const&) = delete;
        // NOTE: can be changed to '= delete' when C++17 becomes mandatory and we can rely on RVO
        UncheckedAccessor(UncheckedAccessor&&) = default;
        auto operator=(UncheckedAccessor const&) -> UncheckedAccessor& = delete;
        auto operator=(UncheckedAccessor&&) -> UncheckedAccessor& = delete;
 
        constexpr auto operator[](SizeType index) && -> Reference {
            return *m_parent->m_storage.pointer_from_index(index);
        }
 
        constexpr auto begin() && noexcept -> Iterator {
            return m_parent->m_storage.pointer_from_index(0);
        }
 
        constexpr auto end() && noexcept -> Iterator {
            return m_parent->m_storage.pointer_from_index(this->m_parent->m_storage.size());
        }
 
        constexpr auto data() && noexcept -> Pointer {
            return m_parent->m_storage.pointer_from_index(0);
        }
    };
 
  private:
    template <typename, uint64_t>
    friend class StaticVector;
    using StorageType = detail::RawByteStorage<T, Capacity>;
    StorageType m_storage;
 
  public:
    // constructors
    constexpr StaticVector() noexcept = default;
    constexpr StaticVector(StaticVector const&) = default;
    constexpr StaticVector(StaticVector&&) = default;
 
    template <uint64_t M, std::enable_if_t<(Capacity >= M), bool> = true>
    // NOLINTNEXTLINE(hicpp-explicit-conversions), conceptually a copy constructor
    constexpr StaticVector(StaticVector<T, M> const& rhs)
        : m_storage(rhs.m_storage) {
    }
 
    template <uint64_t M, std::enable_if_t<(Capacity >= M), bool> = true>
    // NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays), static bounds
    constexpr explicit StaticVector(T const (&element_array)[M]) {
        for (auto& element : element_array) {
            try_push_back(element);
        }
    }
 
    // destructor
    IOX2_CONSTEXPR_DTOR ~StaticVector() = default;
 
    // assignment
    auto operator=(StaticVector const&) -> StaticVector& = default;
    auto operator=(StaticVector&&) -> StaticVector& = default;
 
    template <uint64_t N>
    static constexpr auto from_value(const T& value) -> StaticVector {
        static_assert(N <= Capacity, "Trying to initialize a StaticVector beyond its capacity!");
 
        auto vec = StaticVector {};
        vec.m_storage.insert_at(0, N, value);
        return vec;
    }
 
    template <typename U = T, std::enable_if_t<std::is_default_constructible<U>::value, bool> = true>
    static constexpr auto from_value(SizeType count) -> bb::Optional<StaticVector> {
        if (count <= Capacity) {
            return from_value(count, T {});
        } else {
            return bb::NULLOPT;
        }
    }
 
    static constexpr auto from_value(SizeType count, T const& value) -> bb::Optional<StaticVector> {
        // we define ret here to encourage return-value-optimization
        bb::Optional<StaticVector> ret;
        if (count <= Capacity) {
            ret = StaticVector {};
            ret->m_storage.insert_at(0, count, value);
        } else {
            ret = bb::NULLOPT;
        }
        return ret;
    }
 
    template <typename Iter,
              typename Sentinel,
              std::enable_if_t<
                  std::is_constructible<T, decltype(*std::declval<Iter>())>::value
                      && std::is_convertible<decltype(std::declval<Iter>() == std::declval<Sentinel>()), bool>::value,
                  bool> = true>
    static constexpr auto from_range_unchecked(Iter it_begin, Sentinel it_end) -> bb::Optional<StaticVector> {
        // we define ret here to encourage return-value-optimization
        bb::Optional<StaticVector> ret = StaticVector {};
        for (auto it = it_begin; it != it_end; ++it) {
            if (!ret->try_push_back(*it)) {
                ret = bb::NULLOPT;
                break;
            }
        }
        return ret;
    }
 
    template <typename Range>
    static constexpr auto from_range_unchecked(Range const& rng) -> bb::Optional<StaticVector> {
        using std::begin;
        using std::end;
        return from_range_unchecked(begin(rng), end(rng));
    }
 
 
    static constexpr auto from_initializer_list(std::initializer_list<T> init_list) -> bb::Optional<StaticVector> {
        if (init_list.size() > Capacity) {
            return bb::NULLOPT;
        } else {
            return from_range_unchecked(begin(init_list), end(init_list));
        }
    }
 
    template <typename... Args, std::enable_if_t<std::is_constructible<T, Args...>::value, bool> = true>
    constexpr auto try_emplace_back(Args&&... args) -> bool {
        if (m_storage.size() < Capacity) {
            m_storage.emplace_back(std::forward<Args>(args)...);
            return true;
        } else {
            return false;
        }
    }
 
    template <typename... Args, std::enable_if_t<std::is_constructible<T, Args...>::value, bool> = true>
    constexpr auto try_emplace_at(SizeType index, Args&&... args) -> bool {
        if ((m_storage.size() < Capacity) && (index <= m_storage.size())) {
            m_storage.emplace_at(index, std::forward<Args>(args)...);
            return true;
        } else {
            return false;
        }
    }
 
    constexpr auto try_erase_at(SizeType index) -> bool {
        if (index < m_storage.size()) {
            m_storage.erase_at(index);
            return true;
        } else {
            return false;
        }
    }
 
    constexpr auto try_erase_at(SizeType begin_index, SizeType end_index) -> bool {
        if ((end_index <= m_storage.size()) && (begin_index <= end_index)) {
            m_storage.erase_at(begin_index, end_index);
            return true;
        } else {
            return false;
        }
    }
 
    constexpr auto try_insert_at(SizeType index, T const& value) -> bool {
        return try_emplace_at(index, value);
    }
 
    constexpr auto try_insert_at(SizeType index, T&& value) -> bool {
        return try_emplace_at(index, std::move(value));
    }
 
    constexpr auto try_insert_at(SizeType index, SizeType count, T const& value) -> bool {
        if ((index <= m_storage.size()) && (m_storage.size() + count <= Capacity)) {
            m_storage.insert_at(index, count, value);
            return true;
        } else {
            return false;
        }
    }
 
    template <typename Iter,
              typename Sentinel,
              std::enable_if_t<
                  std::is_constructible<T, decltype(*std::declval<Iter>())>::value
                      && std::is_convertible<decltype(std::declval<Iter>() == std::declval<Sentinel>()), bool>::value,
                  bool> = true>
    constexpr auto try_insert_at_unchecked(SizeType index, Iter it_begin, Sentinel it_end) -> bool {
        if (index <= m_storage.size()) {
            auto const old_size = size();
            for (auto it = it_begin; it != it_end; ++it) {
                if (!try_push_back(*it)) {
                    m_storage.shrink_from_back(old_size);
                    return false;
                }
            }
            m_storage.rotate_from_back(index, old_size);
            return true;
        } else {
            return false;
        }
    }
 
    constexpr auto try_insert_at_unchecked(SizeType index, std::initializer_list<T> init_list) {
        return try_insert_at_unchecked(index, init_list.begin(), init_list.end());
    }
 
    constexpr void clear() {
        m_storage.erase_at(0, m_storage.size());
    }
 
    constexpr auto try_push_back(T const& value) -> bool {
        return try_emplace_back(value);
    }
 
    constexpr auto try_push_back(T&& value) -> bool {
        return try_emplace_back(std::move(value));
    }
 
    constexpr auto try_pop_back() -> bool {
        if (m_storage.size() > 0) {
            m_storage.shrink_from_back(m_storage.size() - 1);
            return true;
        } else {
            return false;
        }
    }
 
    static constexpr auto capacity() noexcept -> SizeType {
        return Capacity;
    }
 
    constexpr auto size() const noexcept -> SizeType {
        return m_storage.size();
    }
 
    constexpr auto empty() const -> bool {
        return size() == 0;
    }
 
    auto element_at(SizeType index) -> OptionalReference {
        if (index < m_storage.size()) {
            return *m_storage.pointer_from_index(index);
        } else {
            return bb::NULLOPT;
        }
    }
 
    auto element_at(SizeType index) const -> OptionalConstReference {
        if (index < m_storage.size()) {
            return *m_storage.pointer_from_index(index);
        } else {
            return bb::NULLOPT;
        }
    }
 
    auto front_element() -> OptionalReference {
        if (!empty()) {
            return *m_storage.pointer_from_index(0);
        } else {
            return bb::NULLOPT;
        }
    }
 
    auto front_element() const -> OptionalConstReference {
        if (!empty()) {
            return *m_storage.pointer_from_index(0);
        } else {
            return bb::NULLOPT;
        }
    }
 
    auto back_element() -> OptionalReference {
        if (!empty()) {
            return *m_storage.pointer_from_index(size() - 1);
        } else {
            return bb::NULLOPT;
        }
    }
 
    auto back_element() const -> OptionalConstReference {
        if (!empty()) {
            return *m_storage.pointer_from_index(size() - 1);
        } else {
            return bb::NULLOPT;
        }
    }
 
    auto unchecked_access() -> UncheckedAccessor {
        return UncheckedAccessor { *this };
    }
 
    auto unchecked_access() const -> UncheckedConstAccessor {
        return UncheckedConstAccessor { *this };
    }
 
    // comparison operators
    friend auto operator==(StaticVector const& lhs, StaticVector const& rhs) -> bool {
        return std::equal(lhs.unchecked_access().begin(),
                          lhs.unchecked_access().end(),
                          rhs.unchecked_access().begin(),
                          rhs.unchecked_access().end());
    }
 
    friend auto operator!=(StaticVector const& lhs, StaticVector const& rhs) -> bool {
        return !(lhs == rhs);
    }
 
    constexpr auto static_memory_layout_metrics() noexcept {
        struct VectorMemoryLayoutMetrics {
            size_t vector_alignment;
            size_t vector_size;
            typename StorageType::StorageMemoryLayoutMetrics storage_metrics;
        } ret;
        using Self = std::remove_reference_t<decltype(*this)>;
        ret.vector_size = sizeof(Self);
        ret.vector_alignment = alignof(Self);
        ret.storage_metrics = m_storage.static_memory_layout_metrics();
        return ret;
    }
};
 
template <typename>
struct IsStaticVector : std::false_type { };
 
template <typename T, uint64_t N>
struct IsStaticVector<StaticVector<T, N>> : std::true_type { };
 
} // namespace bb
} // namespace iox2
 
template <typename T, uint64_t N>
auto operator<<(std::ostream& stream, const iox2::bb::StaticVector<T, N>& value) -> std::ostream& {
    stream << "StaticVector::<" << N << "> { m_size: " << value.size() << ", m_data: [ ";
    if (!value.empty()) {
        stream << value.unchecked_access()[0];
    }
    for (uint64_t idx = 1; idx < value.size(); ++idx) {
        stream << ", " << value.unchecked_access()[idx];
    }
    stream << " ] }";
    return stream;
}
 
#endif // IOX2_INCLUDE_GUARD_BB_STATIC_VECTOR_HPP