fixed_array.hpp

Go to the documentation of this file.

 
#pragma once
#include "array.hpp"
#include "optional.hpp"
#include "string.hpp"
#include "helpers/throw_helper.hpp"
 
namespace xtd {
  template<class type_t, xtd::size len>
  class fixed_array : public xtd::object {
  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 iterator = value_type*;
    using const_iterator = const value_type*;
    using pointer = value_type*;
    using const_pointer = const value_type*;
    using size_type = xtd::size;
    using difference_type = xtd::ptrdiff;
    using reverse_iterator = std::reverse_iterator<iterator>;
    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
    
    
    fixed_array() = default;
    fixed_array(fixed_array&&) = default;
    fixed_array& operator =(fixed_array&&) = default;
    fixed_array(const fixed_array&) = default;
    fixed_array& operator =(const fixed_array&) = default;
    fixed_array(std::initializer_list<type_t> il) {
      auto index = xtd::size {0};
      for (const auto& item : il)
        items_[index++] = item;
    }
    
    
    virtual reference back() {return at(count() - 1);}
    virtual const_reference back() const {return at(count() - 1);}
 
    const_iterator begin() const noexcept {return cbegin();}
    iterator begin() noexcept {return iterator {data()};}
 
    const_iterator cbegin() const noexcept {return const_iterator {data()};}
 
    const_iterator cend() const noexcept {return const_iterator {data() + len};}
    
    size_type count() const noexcept {return size();}
 
    const_pointer data() const noexcept {return items_;}
    pointer data() noexcept {return items_;}
 
    virtual bool empty() const noexcept {return len == xtd::size {0};}
 
    const_iterator end() const noexcept {return cend();}
    iterator end() noexcept {return iterator {data() + len};}
    virtual reference front() {return at(0);}
    virtual const_reference front() const {return at(0);}
 
    virtual const_base_type items() const noexcept {return items_;}
    virtual base_type items() noexcept {return items_;}
 
    virtual size_type length() const noexcept {return size();}
 
    xtd::size size() const noexcept {return len;}
    
    
    virtual const_reference at(size_type index) const {
      if (index >= count()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::index_out_of_range);
      return items_[index];
    }
    virtual reference at(size_type index) {
      if (index >= count()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::index_out_of_range);
      return items_[index];
    }
    
    void clear() noexcept {
      for (auto& item : *this)
        item = value_type {};
    }
 
    void fill(const type_t& value) {
      for (auto& item : *this)
        item = value;
    }
 
    virtual xtd::array<value_type> to_array() const noexcept {return size() ? xtd::array<value_type>(data(), size()) : xtd::array<value_type> {};}
 
    xtd::string to_string() const noexcept override {return xtd::string::format("[{}]", xtd::string::join(", ", *this));}
    
    
    
    const_reference operator [](xtd::size index) const {return at(index);}
    reference operator [](xtd::size index) {return at(index);}
    
  private:
    type_t items_[len];
  };
  
  template <class type_t, class... args_t>
  fixed_array(type_t, args_t...) -> fixed_array<type_t, 1 + sizeof...(args_t)>;
}