fixed_array.hpp

Go to the documentation of this file.

#pragma once
 
/// @file userver/utils/fixed_array.hpp
/// @brief @copybrief utils::FixedArray
 
#include <cstddef>
#include <memory>  // std::allocator
#include <type_traits>
#include <utility>
 
#include <userver/utils/assert.hpp>
#include <userver/utils/impl/internal_tag.hpp>
 
USERVER_NAMESPACE_BEGIN
 
namespace utils {
 
/// @ingroup userver_universal userver_containers
///
/// @brief A fixed-size array with the size determined at runtime.
///
/// The array also allows initializing each of the array elements with the same
/// parameters:
/// @snippet src/utils/fixed_array_test.cpp  Sample FixedArray
template <class T>
class FixedArray final {
public:
    using iterator = T*;
    using const_iterator = const T*;
 
    /// Make an empty array
    FixedArray() = default;
 
    /// Make an array and initialize each element with "args"
    template <class... Args>
    explicit FixedArray(std::size_t size, Args&&... args);
 
    FixedArray(FixedArray&& other) noexcept;
    FixedArray& operator=(FixedArray&& other) noexcept;
 
    FixedArray(const FixedArray&) = delete;
    FixedArray& operator=(const FixedArray&) = delete;
 
    ~FixedArray();
 
    std::size_t size() const noexcept { return size_; }
    bool empty() const noexcept { return size_ == 0; }
 
    const T& operator[](std::size_t i) const noexcept {
        UASSERT(i < size_);
        return data()[i];
    }
 
    T& operator[](std::size_t i) noexcept {
        UASSERT(i < size_);
        return data()[i];
    }
 
    T& front() noexcept { return *NonEmptyData(); }
    const T& front() const noexcept { return *NonEmptyData(); }
 
    T& back() noexcept { return *(NonEmptyData() + size_ - 1); }
    const T& back() const noexcept { return *(NonEmptyData() + size_ - 1); }
 
    T* data() noexcept { return storage_; }
    const T* data() const noexcept { return storage_; }
 
    T* begin() noexcept { return data(); }
    T* end() noexcept { return data() + size_; }
    const T* begin() const noexcept { return data(); }
    const T* end() const noexcept { return data() + size_; }
    const T* cbegin() const noexcept { return data(); }
    const T* cend() const noexcept { return data() + size_; }
 
    /// @cond
    template <class GeneratorFunc>
    FixedArray(impl::InternalTag tag, std::size_t size, GeneratorFunc&& generator);
    /// @endcond
 
private:
    T* NonEmptyData() noexcept {
        UASSERT(size_);
        return data();
    }
 
    const T* NonEmptyData() const noexcept {
        UASSERT(size_);
        return data();
    }
 
    T* storage_{nullptr};
    std::size_t size_{0};
};
 
/// @brief Applies @p generator to indices in the range `[0, size)`, storing the
/// results in a new utils::FixedArray. The generator is guaranteed to be
/// invoked in the first-to-last order.
/// @param size How many objects to generate
/// @param generator A functor that takes an index and returns an object for the
/// `FixedArray`
/// @returns `FixedArray` with the return objects of @p generator
template <class GeneratorFunc>
auto GenerateFixedArray(std::size_t size, GeneratorFunc&& generator);
 
template <class T>
template <class... Args>
FixedArray<T>::FixedArray(std::size_t size, Args&&... args) : size_(size) {
    if (size_ == 0) return;
    storage_ = std::allocator<T>{}.allocate(size_);
 
    auto* begin = data();
    try {
        for (auto* end = begin + size - 1; begin != end; ++begin) {
            new (begin) T(args...);
        }
        new (begin) T(std::forward<Args>(args)...);
    } catch (...) {
        std::destroy(data(), begin);
        std::allocator<T>{}.deallocate(storage_, size);
        throw;
    }
}
FixedArray<T>::FixedArray(std::size_t size, Args&&... args) : size_(size) {…}
    explicit FixedArray(std::size_t size, Args&&... args); {…}
 
template <class T>
template <class GeneratorFunc>
FixedArray<T>::FixedArray(impl::InternalTag /*tag*/, std::size_t size, GeneratorFunc&& generator) : size_(size) {
    if (size_ == 0) return;
    storage_ = std::allocator<T>{}.allocate(size_);
 
    auto* our_begin = begin();
    auto* const our_end = end();
    std::size_t index = 0;
 
    try {
        for (; our_begin != our_end; ++our_begin) {
            new (our_begin) T(generator(index));
            ++index;
        }
    } catch (...) {
        std::destroy(begin(), our_begin);
        std::allocator<T>{}.deallocate(storage_, size_);
        throw;
    }
}
 
template <class T>
FixedArray<T>::FixedArray(FixedArray&& other) noexcept
    : storage_(std::exchange(other.storage_, nullptr)), size_(std::exchange(other.size_, 0)) {}
 
template <class T>
FixedArray<T>& FixedArray<T>::operator=(FixedArray&& other) noexcept {
    std::swap(storage_, other.storage_);
    std::swap(size_, other.size_);
    return *this;
}
 
template <class T>
FixedArray<T>::~FixedArray() {
    std::destroy(begin(), end());
    std::allocator<T>{}.deallocate(storage_, size_);
}
 
template <class GeneratorFunc>
auto GenerateFixedArray(std::size_t size, GeneratorFunc&& generator) {
    using ResultType = std::remove_reference_t<std::invoke_result_t<GeneratorFunc&, std::size_t>>;
    return FixedArray<ResultType>(impl::InternalTag{}, size, std::forward<GeneratorFunc>(generator));
}
auto GenerateFixedArray(std::size_t size, GeneratorFunc&& generator) {…}
 
}  // namespace utils
 
USERVER_NAMESPACE_END
class FixedArray final {…};