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<class type_t, class 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) : basic_array<type_t, allocator_t>(array) {}
    array(array&& array) : basic_array<type_t, allocator_t>(std::move(array)) {}
    array(const base_type& array) : 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::size> {length1, length2, length3}) {}
    array(size_type length1, size_type length2, size_type length3, const value_type& value) : basic_array<type_t, allocator_t>(array<xtd::size> {length1, length2, length3}, value) {}
    explicit array(const array<xtd::size, 1>& lengths) : xtd::basic_array<type_t, allocator_t>(lengths) {}
    array(const array<xtd::size, 1>& lengths, const value_type& value) : basic_array<type_t, allocator_t>(lengths, value) {}
    explicit array(const xtd::collections::generic::ienumerable<type_t>& enumerable) : 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<class input_iterator_t>
    array(input_iterator_t first, input_iterator_t last) : basic_array<type_t, allocator_t>(first, last) {}
    array(std::vector<std::vector<std::vector<type_t>>> items) : basic_array<type_t, allocator_t>(items) {}
    array(std::initializer_list<std::initializer_list<std::initializer_list<type_t>>> items) : basic_array<type_t, allocator_t>(items) {}
    
    
    xtd::size rank() const noexcept override {return 3;}
    
    
    using xtd::basic_array<type_t, allocator_t>::get_value;
    const value_type& get_value(size_type index1, size_type index2, size_type index3) const {return operator()(index1, index2, index3);}
    
    using xtd::basic_array<type_t, allocator_t>::set_value;
    void set_value(const value_type& value, size_type index1, size_type index2, size_type index3) {operator()(index1, index2, index3) = value;}
    
    xtd::string to_string() const noexcept override;
    
    
    array& operator=(const array&) = default;
    array& operator=(array&&) = default;
    
    using xtd::basic_array<type_t, allocator_t>::operator();
    value_type& operator()(size_type index1, size_type index2, size_type index3) {return xtd::basic_array<type_t, allocator_t>::operator()({index1, index2, index3});}
    
    const value_type& operator()(size_type index1, size_type index2, size_type index3) const {return xtd::basic_array<type_t, allocator_t>::operator()({index1, index2, index3});}
  };
}