array_1.hpp

Go to the documentation of this file.

 
#if !defined(__XTD_ARRAY_INTERNAL__)
#error "Do not include this file: Internal use only. Include <xtd/array> or <xtd/array.hpp> instead."
#endif

namespace xtd {
  template<typename type_t, typename allocator_t>
  class array<type_t, 1, allocator_t> : public xtd::basic_array<type_t, allocator_t> {
  public:
    
    using value_type = type_t;
    using allocator_type = typename xtd::basic_array<type_t, allocator_t>::allocator_type;
    using base_type = typename xtd::basic_array<type_t, allocator_t>::base_type;
    using size_type = typename xtd::basic_array<type_t, allocator_t>::size_type;
    using difference_type = typename xtd::basic_array<type_t, allocator_t>::difference_type;
    using reference = typename xtd::basic_array<type_t, allocator_t>::reference;
    using const_reference = typename xtd::basic_array<type_t, allocator_t>::const_reference;
    using pointer = typename xtd::basic_array<type_t, allocator_t>::pointer;
    using const_pointer = typename xtd::basic_array<type_t, allocator_t>::const_pointer;
    using iterator = typename xtd::basic_array<type_t, allocator_t>::iterator;
    using const_iterator = typename xtd::basic_array<type_t, allocator_t>::const_iterator;
    using reverse_iterator = typename xtd::basic_array<type_t, allocator_t>::reverse_iterator;
    using const_reverse_iterator = typename xtd::basic_array<type_t, allocator_t>::const_reverse_iterator;
    
    
    array() = default;
    array(const array& array) requires std::copy_constructible<type_t> : basic_array<type_t, allocator_t>(array) {}
    array(array&& array) : basic_array<type_t, allocator_t>(std::move(array)) {}
    array(const base_type& array) requires std::copy_constructible<type_t> : basic_array<type_t, allocator_t>(array) {}
    array(base_type&& array) : basic_array<type_t, allocator_t>(std::move(array)) {}
    explicit array(size_type length) : basic_array<type_t, allocator_t>(array<xtd::usize> {length}) {}
    array(size_type length, const value_type& value) requires std::copy_constructible<type_t> : basic_array<type_t, allocator_t>(array<xtd::usize> {length}, value) {}
    array(const array<xtd::usize, 1>& lengths, const value_type& value) requires std::copy_constructible<type_t> : basic_array<type_t, allocator_t>(lengths, value) {}
    template<xtd::usize length>
    array(const type_t(&array)[length]) requires std::copy_constructible<type_t> : basic_array<type_t, allocator_t>(array, length) {}
    array(const type_t* array, size_type length) requires std::copy_constructible<type_t> : basic_array<type_t, allocator_t>(array, length) {}
    explicit array(const xtd::collections::generic::ienumerable<type_t>& enumerable) requires std::copy_constructible<type_t> : basic_array<type_t, allocator_t>(enumerable) {}
    explicit array(const xtd::collections::generic::ilist<type_t>& list) requires std::copy_constructible<type_t> : basic_array<type_t, allocator_t>(list) {}
    template<typename input_iterator_t>
    array(input_iterator_t first, input_iterator_t last) requires std::copy_constructible<type_t> : basic_array<type_t, allocator_t>(first, last) {}
    array(std::initializer_list<type_t> items) requires std::copy_constructible<type_t> : basic_array<type_t, allocator_t>(items) {}
    
    
    [[nodiscard]] auto rank() const noexcept -> xtd::usize override {return 1;}
    
    
    
    auto copy_to(xtd::array<type_t>& array, size_type index) const -> void override {
      if constexpr (std::copy_constructible<type_t>) basic_array<type_t, allocator_t>::copy_to(array, index);
      else xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::invalid_operation, "value_type is not copy constructible.");
    }
    
    using xtd::basic_array<type_t, allocator_t>::get_value;
    [[nodiscard]] auto get_value(size_type index) const -> const value_type& {return operator()(index);}
    
    using xtd::basic_array<type_t, allocator_t>::set_value;
    auto set_value(const value_type& value, size_type index) -> void requires std::copy_constructible<type_t> {operator()(index) = value;}
    
    [[nodiscard]] auto to_string() const noexcept -> xtd::string override;
    
    
    auto operator=(const array&) -> array& requires std::copy_constructible<type_t> = default;
    auto operator=(array&&) -> array& = default;
    
    using xtd::basic_array<type_t, allocator_t>::operator();
    [[nodiscard]] auto operator()(size_type index) -> value_type& {return xtd::basic_array<type_t, allocator_t>::operator[](index);}
    
    [[nodiscard]] auto operator()(size_type index) const -> const value_type& {return xtd::basic_array<type_t, allocator_t>::operator[](index);}
    
    [[nodiscard]] auto operator[](size_type index) -> value_type& override {return xtd::basic_array<type_t, allocator_t>::operator[](index);}
    
    [[nodiscard]] auto operator[](size_type index) const -> const value_type& override {return xtd::basic_array<type_t, allocator_t>::operator[](index);}
  };
}