array_1.h

Go to the documentation of this file.

 
 
#if !defined(__XTD_ARRAY_INTERNAL__)
#error "Do not include this file: Internal use only. Include <array> or <array.h> 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) : basic_array<type_t, allocator_t>(array) {}
    array_(const 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>(array) {}
    array_(size_type length) : basic_array<type_t, allocator_t>(array_<xtd::size> {length}) {}
    array_(std::initializer_list<type_t> items) : basic_array<type_t, allocator_t>(items) {}
    template<xtd::size length>
    array_(const type_t(&array)[length]) : basic_array<type_t, allocator_t>(array, length) {}
    array_(const type_t* array, size_type length) : basic_array<type_t, allocator_t>(array, length) {}
    array_(const xtd::collections::generic::ienumerable<type_t>& enumerable) : basic_array<type_t, allocator_t>(enumerable) {}
    array_(const xtd::collections::generic::ilist<type_t>& list) : basic_array<type_t, allocator_t>(list) {}
    template<typename iterator_t>
    array_(iterator_t first, iterator_t last) : basic_array<type_t, allocator_t>(first, last) {}
 
    
    xtd::size rank() const noexcept override {return 1;}
 
    
 
    void copy_to(xtd::array<type_t>& array, size_type index) const override {basic_array<type_t, allocator_t>::copy_to(array, index);}
 
    using xtd::basic_array<type_t, allocator_t>::get_value;
    const value_type& get_value(size_type index) const {return operator()(index);}
    
    using xtd::basic_array<type_t, allocator_t>::set_value;
    void set_value(const value_type& value, size_type index) {operator()(index) = value;}
 
 
    
    array_& operator=(const array_&) = default;
    array_& operator=(array_&&) = default;
    
    using xtd::basic_array<type_t, allocator_t>::operator();
    value_type& operator()(size_type index) {return xtd::basic_array<type_t, allocator_t>::operator[](index);}
    
    const value_type& operator()(size_type index) const {return xtd::basic_array<type_t, allocator_t>::operator[](index);}
    
    value_type& operator[](size_type index) override {return xtd::basic_array<type_t, allocator_t>::operator[](index);}
    
    const value_type& operator[](size_type index) const override {return xtd::basic_array<type_t, allocator_t>::operator[](index);}
  };
}