AStaticVector.h

/*
 * AUI Framework - Declarative UI toolkit for modern C++20
 * Copyright (C) 2020-2025 Alex2772 and Contributors
 *
 * SPDX-License-Identifier: MPL-2.0
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */
 
#pragma once
 
#include "AVector.h"
#include "AException.h"
#include <utility>
#include <span>
 
 
#define AUI_ASSERT_MY_ITERATOR(it) AUI_ASSERTX((this->begin() <= it && it <= this->end()), "foreign iterator")

template<typename StoredType, std::size_t MaxSize>
class AStaticVector {
public:
   using self = AStaticVector;
   using super = AStaticVector;
   using iterator = StoredType*;
   using const_iterator = const StoredType*;
   using reference = StoredType&;
   using const_reference = const StoredType&;
   using value = StoredType;
 
   constexpr AStaticVector() noexcept: mBegin(reinterpret_cast<StoredType*>(&mStorage)), mEnd(mBegin) {}
   constexpr AStaticVector(const AStaticVector& rhs): AStaticVector() {
       insert(mBegin, rhs.begin(), rhs.end());
   }
   constexpr AStaticVector(AStaticVector&& rhs) noexcept: AStaticVector() {
       insert(mBegin, std::make_move_iterator(rhs.begin()), std::make_move_iterator(rhs.end()));
       rhs.clear();
   }
   constexpr AStaticVector(std::initializer_list<StoredType> rhs) noexcept: AStaticVector() {
       insert(mBegin, std::make_move_iterator(rhs.begin()), std::make_move_iterator(rhs.end()));
   }
   template<typename Iterator>
   constexpr AStaticVector(Iterator begin, Iterator end) noexcept: AStaticVector() {
       for (auto it = begin; it != end; ++it) { // range-v3 fix: basic range traversal instead of insert
           push_back(*it);
       }
   }
   constexpr ~AStaticVector() {
       for (auto& v : *this) {
           v.~StoredType();
       }
   }
 
   [[nodiscard]]
   static constexpr size_t capacity() noexcept {
       return MaxSize;
   }
 
   AStaticVector& operator=(const AStaticVector& rhs) {
       if (this == &rhs) {
           return *this;
       }
       clear();
       insert(mBegin, rhs.begin(), rhs.end());
       return *this;
   }
 
   AStaticVector& operator=(AStaticVector&& rhs) noexcept {
       if (this == &rhs) {
           return *this;
       }
       clear();
       insert(mBegin, std::make_move_iterator(rhs.begin()), std::make_move_iterator(rhs.end()));
       rhs.clear();
       return *this;
   }
 
   [[nodiscard]]
   constexpr bool full() const noexcept {
       return size() >= MaxSize;
   }
 
   [[nodiscard]]
   constexpr StoredType* data() noexcept {
       return mBegin;
   }
   [[nodiscard]]
   constexpr const StoredType* data() const noexcept {
       return mBegin;
   }
 
   [[nodiscard]]
   constexpr iterator begin() noexcept {
       return mBegin;
   }
   [[nodiscard]]
   constexpr const_iterator begin() const noexcept {
       return mBegin;
   }
 
   [[nodiscard]]
   constexpr iterator end() noexcept {
       return mEnd;
   }
 
   [[nodiscard]]
   constexpr const_iterator end() const noexcept {
       return mEnd;
   }
 
   [[nodiscard]]
   constexpr StoredType& front() noexcept {
       return *begin();
   }
 
   [[nodiscard]]
   constexpr StoredType& back() noexcept {
       return *std::prev(end());
   }
 
   [[nodiscard]]
   constexpr const StoredType& front() const noexcept {
       return *begin();
   }
 
   [[nodiscard]]
   constexpr const StoredType& back() const noexcept {
       return *std::prev(end());
   }
 
   template<typename... Args>
   constexpr void emplace_back(Args&&... args) noexcept {
       AUI_ASSERTX(!full(), "insufficient size in AStaticVector");
       new (mEnd++) StoredType(std::forward<Args>(args)...);
   }
 
 
   constexpr void push_back(StoredType value) noexcept {
       AUI_ASSERTX(!full(), "insufficient size in AStaticVector");
       new (mEnd++) StoredType(std::move(value));
   }
 
   constexpr void push_front(StoredType value) noexcept {
       AUI_ASSERTX(!full(), "insufficient size in AStaticVector");
       insert(begin(), std::move(value));
   }
 
   constexpr void pop_back() noexcept {
       AUI_ASSERTX(size() > 0, "AStaticVector is empty");
       erase(std::prev(end()));
   }
   constexpr void pop_front() noexcept {
       AUI_ASSERTX(size() > 0, "AStaticVector is empty");
       erase(begin());
   }
 
   [[nodiscard]]
   constexpr StoredType& operator[](std::size_t index) noexcept {
       AUI_ASSERTX(index < size(), "out of bounds");
       return *(data() + index);
   }
 
   [[nodiscard]]
   constexpr StoredType& operator[](std::size_t index) const noexcept {
       return const_cast<AStaticVector*>(this)->operator[](index);
   }
 
   [[nodiscard]]
   constexpr bool empty() const noexcept {
       return begin() == end();
   }
 
   constexpr void clear() noexcept {
       for (auto& v : *this) {
           v.~StoredType();
       }
       mEnd = mBegin;
   }
 
   [[nodiscard]]
   constexpr std::size_t size() const noexcept {
       return mEnd - mBegin;
   }
 
   template<typename OtherIterator>
   constexpr iterator insert(iterator at, OtherIterator begin, OtherIterator end) {
       AUI_ASSERT_MY_ITERATOR(at);
       auto distance = std::distance(begin, end);
       AUI_ASSERTX(size() + distance <= MaxSize, "out of bounds");
 
       return aui::container::vector_impl::insert_no_growth(mEnd, at, begin, end);
   }
 
   constexpr iterator insert(iterator at, StoredType value) {
       AUI_ASSERT_MY_ITERATOR(at);
       return insert(at, std::make_move_iterator(&value), std::make_move_iterator(&value + 1));
   }
 
   constexpr iterator erase(iterator at) {
       return erase(at, std::next(at));
   }
 
   constexpr iterator erase(iterator begin, iterator end) {
       AUI_ASSERT_MY_ITERATOR(begin);
       AUI_ASSERT_MY_ITERATOR(end);
 
       return aui::container::vector_impl::erase(mBegin, mEnd, begin, end);
   }
 
   void reserve(std::size_t) {
       // does nothing - just for std::vector compatibility
   }
 
   // AUI extensions - see AVector for reference
 

   template<typename OtherContainer>
   iterator insertAll(const OtherContainer& c) noexcept {
       return insertAll(super::end(), c);
   }
 

   template<typename OtherContainer>
   iterator insertAll(OtherContainer&& c) noexcept {
       return insertAll(super::end(), std::forward<OtherContainer>(c));
   }
 

   template<typename OtherContainer>
   iterator insertAll(iterator at, const OtherContainer& c) noexcept {
       return super::insert(at, c.begin(), c.end());
   }
 

   template<typename OtherContainer>
   iterator insertAll(iterator at, OtherContainer&& c) noexcept {
       return super::insert(at, std::make_move_iterator(c.begin()), std::make_move_iterator(c.end()));
   }
 

   void removeAll(const StoredType& item) noexcept
   {
       aui::container::remove_all(*this, item);
   }

   void removeFirst(const StoredType& item) noexcept
   {
       aui::container::remove_first(*this, item);
   }
 

   template<typename OtherContainer>
   bool isSubsetOf(const OtherContainer& c) const noexcept
   {
       return aui::container::is_subset(*this, c);
   }

   bool contains(const StoredType& value) const noexcept {
       return aui::container::contains(*this, value);
   }
 
   [[nodiscard]]
   std::size_t sizeInBytes() const noexcept {
       return super::size() * sizeof(StoredType);
   }
 
   [[nodiscard]]
   StoredType& at(std::size_t index) {
       if (index >= super::size()) {
           aui::impl::outOfBoundsException();
       }
       return super::operator[](index);
   }
 
   [[nodiscard]]
   const StoredType& at(std::size_t index) const {
       if (index >= super::size()) {
           aui::impl::outOfBoundsException();
       }
       return super::operator[](index);
   }
 

   self& operator<<(const StoredType& rhs) noexcept
   {
       super::push_back(rhs);
       return *this;
   }

   self& operator<<(StoredType&& rhs) noexcept
   {
       super::push_back(std::forward<StoredType>(rhs));
       return *this;
   }

   template<typename OtherContainer, std::enable_if_t<!std::is_convertible_v<OtherContainer, StoredType>, bool> = true>
   self& operator<<(const OtherContainer& c) noexcept
   {
       insertAll(c);
       return *this;
   }

   template<typename OtherContainer, std::enable_if_t<!std::is_convertible_v<OtherContainer, StoredType>, bool> = true>
   self& operator<<(OtherContainer&& c) noexcept
   {
       insertAll(std::forward<OtherContainer>(c));
       return *this;
   }
 

   StoredType& first() noexcept
   {
       AUI_ASSERTX(!super::empty(), "empty container could not have the first element");
       return super::front();
   }

   const StoredType& first() const noexcept
   {
       AUI_ASSERTX(!super::empty(), "empty container could not have the first element");
       return super::front();
   }

   StoredType& last() noexcept
   {
       AUI_ASSERTX(!super::empty(), "empty container could not have the last element");
       return super::back();
   }

   const StoredType& last() const noexcept
   {
       AUI_ASSERTX(!super::empty(), "empty container could not have the last element");
       return super::back();
   }

   [[nodiscard]]
   AOptional<size_t> indexOf(const StoredType& value) const noexcept
   {
       return aui::container::index_of(*this, value);
   }
 
 
   void sort() noexcept {
       std::sort(super::begin(), super::end());
   }
 
   template<typename Comparator>
   void sort(Comparator&& comparator) noexcept {
       std::sort(super::begin(), super::end(), std::forward<Comparator>(comparator));
   }

   void removeAt(size_t index) noexcept
   {
       aui::container::remove_at(*this, index);
   }

   template<typename Predicate>
   void removeIf(Predicate&& predicate) noexcept
   {
       super::erase(std::remove_if(super::begin(), super::end(), std::forward<Predicate>(predicate)), super::end());
   }
 
   ASet<StoredType> toSet() const noexcept {
       return ASet<StoredType>(super::begin(), super::end());
   }

   template<aui::incrementable Iterator, aui::invocable<decltype(*std::declval<Iterator>())> UnaryOperation>
   static auto fromRange(aui::range<Iterator> range, UnaryOperation&& transformer) -> AVector<decltype(transformer(range.first()))> {
       AVector<decltype(transformer(range.first()))> result;
       result.reserve(range.size());
       std::transform(range.begin(), range.end(), std::back_inserter(result), std::forward<UnaryOperation>(transformer));
       return result;
   }
 
   template<aui::invocable<const StoredType&> UnaryOperation>
   auto map(UnaryOperation&& transformer) const -> AVector<decltype(transformer(std::declval<StoredType>()))> {
       AVector<decltype(transformer(std::declval<StoredType>()))> result;
       result.reserve(super::size());
       std::transform(super::begin(), super::end(), std::back_inserter(result), std::forward<UnaryOperation>(transformer));
       return result;
   }
 
   template<aui::invocable<const StoredType&> UnaryOperation>
   [[nodiscard]]
   auto toMap(UnaryOperation&& transformer) const -> AMap<decltype(transformer(std::declval<StoredType>()).first),
           decltype(transformer(std::declval<StoredType>()).second)> {
       return aui::container::to_map(super::begin(), super::end(), transformer);
   }
 
   template<aui::invocable<StoredType&> UnaryOperation>
   [[nodiscard]]
   auto toMap(UnaryOperation&& transformer) -> AMap<decltype(transformer(std::declval<StoredType>()).first),
           decltype(transformer(std::declval<StoredType>()).second)> {
       return aui::container::to_map(super::begin(), super::end(), transformer);
   }
 
   template<aui::predicate<const StoredType&> Predicate>
   self filter(Predicate&& predicate) {
       self result;
       result.reserve(super::size());
       for (const auto& element : *this) {
           if (predicate(element)) {
               result.push_back(element);
           }
       }
       return result;
   }
 
   [[nodiscard]]
   operator std::span<StoredType>() {
       return std::span(data(), size());
   }
 
   [[nodiscard]]
   operator std::span<const StoredType>() const {
       return std::span(data(), size());
   }
 
private:
   iterator mBegin;
   iterator mEnd;
   std::aligned_storage_t<sizeof(StoredType) * MaxSize, alignof(StoredType)> mStorage;
};

© 2025 AUI Framework Contributors. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. All trademarks are property of their respective owners.