array.hpp

Go to the documentation of this file.

#pragma once
#define __XTD_CORE_INTERNAL__
#include "internal/__array_definition.hpp"
#undef __XTD_CORE_INTERNAL__
#include "collections/generic/helpers/equator.hpp"
#include "collections/generic/helpers/lesser.hpp"
#include "collections/generic/helpers/raw_array.hpp"
#include "collections/generic/comparer.hpp"
#include "collections/generic/enumerator.hpp"
#include "collections/generic/icomparer.hpp"
#include "collections/generic/ilist.hpp"
#include "helpers/throw_helper.hpp"
#include "abstract.hpp"
#include "byte.hpp"
#include "core_export.hpp"
#include "int64.hpp"
#include "iequatable.hpp"
#include "new_ptr.hpp"
#include "null.hpp"
#include "object.hpp"
#include "self.hpp"
#include "static.hpp"
#include <algorithm>
 
#define __XTD_ARRAY_INTERNAL__
#include "array_abstract_object.hpp"
#include "basic_array.hpp"
#undef __XTD_ARRAY_INTERNAL__

namespace xtd {
  template<typename type_t, xtd::usize rank_, typename allocator_t>
  class array : public 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> : xtd::basic_array<type_t, allocator_t>(array) {}
    array(array&& array) : xtd::basic_array<type_t, allocator_t>(std::move(array)) {}
    explicit array(const array<xtd::usize, 1>& lengths) : xtd::basic_array<type_t, allocator_t>(lengths) {}
    array(const array<xtd::usize, 1>& lengths, const type_t& value) requires std::copy_constructible<type_t> : xtd::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<typename input_iterator_t>
    array(input_iterator_t first, input_iterator_t last) : basic_array<type_t, allocator_t>(first, last) {}
    array(std::initializer_list<type_t> items) : basic_array<type_t, allocator_t>(items) {}
    
    
    xtd::usize rank() const noexcept override {return rank_;}
    
    
    xtd::string to_string() const noexcept override;
    
    
    array& operator=(const array&) = default;
    array& operator=(array&&) = default;
    
  private:
    friend class array<>;
    array(const array<xtd::usize>& lengths, bool) : basic_array<type_t, allocator_t>(lengths) {}
  };
}
 
#define __XTD_ARRAY_INTERNAL__
#include "array_1.hpp"
#include "array_2.hpp"
#include "array_3.hpp"
#include "array_static.hpp"
#include "array_.hpp"
#undef __XTD_ARRAY_INTERNAL__
#define __XTD_CORE_INTERNAL__
#include "helpers/throw_helper.hpp"
#undef __XTD_CORE_INTERNAL__

template<typename source_t, typename enumerable_t>
inline xtd::array<source_t> xtd::collections::generic::extensions::enumerable<source_t, enumerable_t>::to_array() const {
  return xtd::linq::enumerable::to_array(self());
}
 
template<xtd::iterable source_t>
auto xtd::linq::enumerable::chunk(source_t&& source, xtd::usize size) -> xtd::collections::generic::enumerable_generator<xtd::array<xtd::iterable_value_type<source_t>>> {
  if (size == 0) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
  
  auto source_holder = __xtd_enumerable_holder<xtd::raw_type<source_t>> {std::forward<xtd::raw_type<source_t>>(source)};
  auto buffer = std::vector<xtd::iterable_value_type<source_t>> {};
  buffer.reserve(size);
  
  for (const auto& item : source_holder.get()) {
    buffer.push_back(item);
    if (buffer.size() == size) {
      co_yield std::move(buffer);
      buffer = {};
      buffer.reserve(size);
    }
  }
  
  if (!buffer.empty())
    co_yield std::move(buffer);
}
 
template<typename source_t>
auto xtd::linq::enumerable::to_array(const xtd::collections::generic::ienumerable<source_t>& source) {
  return xtd::array<source_t> {source};
}