array_3.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, 3, 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)) {}
    array(size_type length1, size_type length2, size_type length3) : basic_array<type_t, allocator_t>(array<xtd::usize> {length1, length2, length3}) {}
    array(size_type length1, size_type length2, size_type length3, const value_type& value) requires std::copy_constructible<type_t> : basic_array<type_t, allocator_t>(array<xtd::usize> {length1, length2, length3}, value) {}
    explicit array(const array<xtd::usize, 1>& lengths) : xtd::basic_array<type_t, allocator_t>(lengths) {}
    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) {}
    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) : 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::vector<std::vector<std::vector<type_t>>> items) requires std::copy_constructible<type_t> : basic_array<type_t, allocator_t>(items) {}
    array(std::initializer_list<std::initializer_list<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 3;}
    
    
    using xtd::basic_array<type_t, allocator_t>::get_value;
    [[nodiscard]] auto get_value(size_type index1, size_type index2, size_type index3) const -> const value_type& {return operator()(index1, index2, index3);}
    
    using xtd::basic_array<type_t, allocator_t>::set_value;
    auto set_value(const value_type& value, size_type index1, size_type index2, size_type index3) -> void {operator()(index1, index2, index3) = value;}
    
    [[nodiscard]] auto to_string() const noexcept -> xtd::string override;
    
    
    auto operator=(const array&) -> array& = default;
    auto operator=(array&&) -> array& = default;
    
    using xtd::basic_array<type_t, allocator_t>::operator();
    [[nodiscard]] auto operator()(size_type index1, size_type index2, size_type index3) -> value_type& {return xtd::basic_array<type_t, allocator_t>::operator()({index1, index2, index3});}
    
    [[nodiscard]] auto operator()(size_type index1, size_type index2, size_type index3) const -> const value_type& {return xtd::basic_array<type_t, allocator_t>::operator()({index1, index2, index3});}
    
#if __cpp_multidimensional_subscript
    using xtd::basic_array<type_t, allocator_t>::operator [];
    auto operator[](size_type index1, size_type index2, size_type index3) -> value_type& {return xtd::basic_array<type_t, allocator_t>::operator()({index1, index2, index3});}

    auto operator[](size_type index1, size_type index2, size_type index3) const -> const value_type& {return xtd::basic_array<type_t, allocator_t>::operator()({index1, index2, index3});}
#endif
  };
}