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<class type_t, xtd::size rank_, class 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) : 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::size, 1>& lengths) : xtd::basic_array<type_t, allocator_t>(lengths) {}
    array(const array<xtd::size, 1>& lengths, const type_t& value) : 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<class 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::size 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::size>& 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<class source_t>
auto xtd::linq::enumerable::chunk(const ienumerable<source_t>& source, size_t size) {
  if (size == 0) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
  auto chunks = __opaque_xtd_linq_enumerable_collection__<xtd::array<source_t>> {};
  chunks = __opaque_xtd_linq_enumerable_collection__<xtd::array<source_t>> {};
  auto chunk = std::vector<source_t> {};
  for (auto index = size_t {0}; const auto& item : source) {
    chunk.push_back(item);
    if (++index % size == 0) {
      chunks.items.push_back(chunk);
      chunk = std::vector<source_t> {};
    }
  }
  if (chunk.size() != 0) chunks.items.push_back(chunk);
  
  return chunks;
}