fixed_array.hpp

Go to the documentation of this file.

#pragma once
#include "array.hpp"
#include "iequatable.hpp"
#include "index.hpp"
#include "optional.hpp"
#include "npos.hpp"
#include "range.hpp"
#include "read_only_span.hpp"
#include "span.hpp"
#include "string.hpp"
#include "collections/generic/ienumerable.hpp"
#include "helpers/throw_helper.hpp"
#include <concepts>

namespace xtd {
  template<typename type_t, xtd::usize len>
  class fixed_array : public xtd::object, public xtd::collections::generic::ienumerable<type_t>, public xtd::iequatable<fixed_array<type_t, len>> {
  public:
    
    using value_type = type_t;
    using base_type = value_type*;
    using const_base_type = const value_type*;
    using reference = value_type&;
    using const_reference = const value_type&;
    using pointer = value_type*;
    using const_pointer = const value_type*;
    using size_type = xtd::usize;
    using difference_type = xtd::ptrdiff;
    
    
    fixed_array() = default;
    fixed_array(std::initializer_list<type_t> items) {
      auto index = xtd::usize {0};
      for (const auto& item : items)
        items_[index++] = item;
    }


    fixed_array(fixed_array&&) = default;
    fixed_array& operator =(fixed_array&&) = default;
    fixed_array(const fixed_array&) = default;
    fixed_array& operator =(const fixed_array&) = default;
    
    
    [[nodiscard]] auto count() const noexcept -> size_type {return size();}
    
    [[nodiscard]] auto data() const noexcept -> const_pointer {return items_;}
    [[nodiscard]] auto data() noexcept -> pointer {return items_;}
    
    [[nodiscard]] virtual auto empty() const noexcept -> bool {return len == xtd::usize {0};}
    
    [[nodiscard]] virtual auto items() const noexcept -> const_base_type {return items_;}
    [[nodiscard]] virtual auto items() noexcept -> base_type {return items_;}
    
    [[nodiscard]] virtual auto length() const noexcept -> size_type {return len;}
    
    [[nodiscard]] auto size() const noexcept -> size_type {return length();}
    
    
    auto clear() noexcept -> void {fill(value_type {});}
    
    [[nodiscard]] auto contains(const value_type& value) const noexcept -> bool {
      for (const auto& item : items_)
        if (xtd::collections::generic::helpers::equator<type_t> {}(reinterpret_cast<const value_type&>(item), value)) return true;
      return false;
    }
    
    auto copy_to(xtd::array<value_type>& array) const -> void {
      copy_to(0, array, 0);
    }
    
    auto copy_to(xtd::array<value_type>& array, size_type array_index) const -> void {
      return copy_to(0, array, array_index);
    }

    auto copy_to(const size_type index, xtd::array<value_type>& array, size_type array_index) const -> void {
      return copy_to(index, array, array_index, length() - index);
    }

    auto copy_to(const size_type index, xtd::array<value_type>& array, size_type array_index, size_type count) const -> void {
      if (array.rank() != 1) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument);
      if (index + count > self_.length() || array_index + count > array.length()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
      for (auto i = index; i < (index + count); ++i)
        array[array_index++] = self_[i];
    }
    
    [[nodiscard]] auto equals(const object & obj) const noexcept -> bool override {return dynamic_cast<const fixed_array<value_type, len>*>(&obj) && equals(static_cast<const fixed_array<value_type, len>&>(obj));}
    [[nodiscard]] auto equals(const fixed_array & rhs) const noexcept -> bool override {
      if (count() != rhs.count()) return false;
      for (size_type i = 0; i < count(); i++)
        if (!xtd::collections::generic::helpers::equator<type_t> {}(items_[i], rhs.items_[i])) return false;
      return true;
    }

    auto fill(const value_type& value) -> void {
      for (auto& item : *this)
        item = value;
    }
    
    [[nodiscard]] auto get_enumerator() const -> xtd::collections::generic::enumerator<value_type> override {
      struct fixed_array_enumerator : public xtd::collections::generic::ienumerator < value_type > {
        explicit fixed_array_enumerator(const fixed_array & items) : items_(items) {}
        
        [[nodiscard]] const value_type& current() const override {
          if (index_ >= items_.length()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::invalid_operation);
          return items_[index_];
        }
        bool move_next() override {return ++index_ < items_.count();}
        void reset() override {index_ = xtd::npos;}
        
      private:
        size_type index_ = xtd::npos;
        const fixed_array& items_;
      };
      return {new_ptr<fixed_array_enumerator>(*this)};
    }
    
    [[nodiscard]] auto index_of(const value_type& value) const noexcept -> size_type {return index_of(value, 0, length());}
    [[nodiscard]] auto index_of(const value_type& value, size_type index) const -> size_type {return index_of(value, index, length() - index);}
    [[nodiscard]] auto index_of(const value_type& value, size_type index, size_type count) const -> size_type {
      if (index > length() || index + count > length()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
      for (auto increment = index; increment < (index + count); ++increment)
        if (xtd::collections::generic::helpers::equator<type_t> {}(items_[increment], value)) return increment;
      return xtd::npos;
    }
    
    auto sort() -> fixed_array& {return sort(dynamic_cast<const xtd::collections::generic::icomparer<type_t>&>(xtd::collections::generic::comparer<type_t>::default_comparer));}
    
    template<typename comparison_t>
    auto sort(comparison_t&& comparison) -> fixed_array& {
      std::sort(items_, items_ + length(), [&](const type_t& x, const type_t& y) {return comparison(x, y) < 0;});
      return self_;
    }
    
    auto sort(const xtd::collections::generic::icomparer<type_t>& comparer) -> fixed_array& {
      return sort(0, count(), comparer);
    }
    
    auto sort(xtd::usize index, xtd::usize count, const xtd::collections::generic::icomparer<type_t>& comparer) -> fixed_array& {
      if (index + count > length()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument);
      std::sort(items_, items_ + length(), xtd::collections::generic::helpers::lesser<type_t> {comparer});
      return self_;
    }

    [[nodiscard]] auto to_array() const noexcept -> xtd::array<value_type> requires std::copy_constructible<value_type> {return size() ? xtd::array<value_type>(items_, items_ + len) : xtd::array<value_type> {};}
    
    [[nodiscard]] auto to_string() const noexcept -> xtd::string override {return xtd::string::format("[{}]", xtd::string::join(", ", *this));}
    
    
    auto operator [](size_type index) const -> const_reference {
      if (index >= count()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::index_out_of_range);
      return items_[index];
    }

    auto operator [](size_type index) -> reference {
      if (index >= count()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::index_out_of_range);
      return items_[index];
    }

    auto operator [](const xtd::index& index) const -> const_reference {
      return operator[](index.get_offset(length()));
    }

    auto operator [](const xtd::index& index) -> reference {
      return operator[](index.get_offset(length()));
    }

    auto operator [](const xtd::range& range) const -> xtd::read_only_span<value_type> {
      return xtd::read_only_span<value_type> {*this, range};
    }

    auto operator [](const xtd::range& range) -> xtd::span<value_type> {
      return xtd::span<value_type> {*this, range};
    }

    auto operator ()(size_type index) const -> const_reference {
      return operator[](index);
    }

    auto operator ()(size_type index) -> reference {
      return operator[](index);
    }

    auto operator ()(const xtd::index& index) const -> const_reference {
      return operator[](index);
    }

    auto operator ()(const xtd::index& index) -> reference {
      return operator[](index);
    }

    auto operator ()(const xtd::range& range) const -> xtd::read_only_span<value_type> {
      return operator[](range);
    }

    auto operator ()(const xtd::range& range) -> xtd::span<value_type> {
      return operator[](range);
    }

    
  private:
    type_t items_[len];
  };

  // Deduction guides for xtd::fixed_array
  // {
  template<typename type_t, typename... args_t>
  fixed_array(type_t, args_t...) -> fixed_array <type_t, 1 + sizeof...(args_t)>;
  // }
}