array_static.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
 
#include "collections/generic/helpers/lesser.hpp"
#include "collections/generic/comparer.hpp"
#include "helpers/throw_helper.hpp"

namespace xtd {
  namespace collections::object_model {
    template<typename type_t>
    class read_only_collection;
  }
  
  template<>
  class array<> static_ {
  public:
    
    
    
    template<typename type_t, typename allocator_t>
    [[nodiscard]] static auto as_read_only(const xtd::array<type_t, 1, allocator_t>& array) -> xtd::collections::object_model::read_only_collection<type_t>; // defined in array_.hpp file
    
    template<typename type_t, typename allocator_t, typename value_t>
    [[nodiscard]] static auto binary_search(const array<type_t, 1, allocator_t>& array, int32 index, int32 length, const value_t& value) -> xtd::usize {return binary_search(array, index, length, value, xtd::collections::generic::comparer<type_t>::default_comparer);}
    template<typename type_t, typename allocator_t, typename value_t>
    [[nodiscard]] static auto binary_search(const array<type_t, 1, allocator_t>& array, xtd::usize index, xtd::usize count, const value_t& value, const xtd::collections::generic::icomparer<type_t>& comparer) -> xtd::usize {
      if (index + count > array.length()) helpers::throw_helper::throws(xtd::helpers::exception_case::index_out_of_range);
      auto first = array.data_->items.begin();
      auto last = array.data_->items.begin();
      std::advance(first, index);
      std::advance(last, index + count);
      auto position = std::lower_bound(first, last, value, xtd::collections::generic::helpers::lesser<type_t> {comparer});
      
      if (position != array.data_->items.end() && !comparer.compare(value, *position))
        return std::distance(array.data_->items.begin(), position);
      return ~std::distance(array.data_->items.begin(), position);
    }

    template<typename type_t, typename allocator_t, typename value_t>
    [[nodiscard]] static auto binary_search(const array<type_t, 1, allocator_t>& array, const value_t& value) -> xtd::usize {return binary_search(array, 0, array.length(), value, xtd::collections::generic::comparer<type_t>::default_comparer);}
    template<typename type_t, typename allocator_t, typename value_t>
    [[nodiscard]] static auto binary_search(const array<type_t, 1, allocator_t>& array, const value_t& value, const xtd::collections::generic::icomparer<type_t>& comparer) -> xtd::usize {return binary_search(array, 0, array.length(), value, comparer);}
    
    template<typename type_t, xtd::usize rank, typename allocator_t>
    static auto clear(const array<type_t, rank, allocator_t>& array) -> void {clear(array, 0, array.data_->items.size());}
    template<typename type_t, xtd::usize rank, typename allocator_t>
    static auto clear(const array<type_t, rank, allocator_t>& array, xtd::usize index, xtd::usize length) -> void {
      if (index + length > array.data_->items.size()) helpers::throw_helper::throws(xtd::helpers::exception_case::index_out_of_range);
      for (auto increment = xtd::usize {}; increment < length; ++increment)
        array.data_->items[index + increment] = type_t {};
    }
    
    template<typename source_type_t, xtd::usize source_rank, typename source_allocator_t, typename destination_type_t, xtd::usize destination_rank, typename destination_allocator_t>
    static auto constrained_copy(const array<source_type_t, source_rank, source_allocator_t>& source_array, const xtd::array<xtd::usize>& source_indexes, array<destination_type_t, destination_rank, destination_allocator_t>& destination_array, const xtd::array<xtd::usize>& destination_indexes, xtd::usize length) -> void {constrained_copy(source_array, xtd::basic_array<source_type_t, source_allocator_t>::compute_index(source_indexes), destination_array, xtd::basic_array<destination_type_t, destination_allocator_t>::compute_index(destination_indexes), length);}
    template<typename source_type_t, xtd::usize source_rank, typename source_allocator_t, typename destination_type_t, xtd::usize destination_rank, typename destination_allocator_t>
    static auto constrained_copy(const array<source_type_t, source_rank, source_allocator_t>& source_array, xtd::usize source_index, array<destination_type_t, destination_rank, destination_allocator_t>& destination_array, xtd::usize destination_index, xtd::usize length) -> void {
      if (source_array.rank() != destination_array.rank()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::rank);
      for (auto r = xtd::usize {0}; r < source_array.rank(); ++r)
        if (source_array.get_length(r) != destination_array.get_length(r)) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument);
      if (source_index < source_array.get_lower_bound(0) || destination_index < destination_array.get_lower_bound(0)) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument_out_of_range);
      if (source_index + length > source_array.length() || destination_index + length > destination_array.length()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::argument);
      
      auto tmp_array = destination_array;
      for (auto i = source_index; i < (source_index + length); ++i)
        tmp_array.data_->items[destination_index++] = source_array.data_->items[i];
      destination_array.data_->items.swap(tmp_array.data_->items);
    }
    
    template<typename output_t, typename input_t, xtd::usize rank, typename allocator_t, typename converter_t, typename destination_allocator_t = xtd::collections::generic::helpers::allocator<output_t>>
    [[nodiscard]] static auto convert_all(const xtd::array<input_t, rank, allocator_t>& array, converter_t converter) -> xtd::array<output_t, rank, destination_allocator_t> {
      auto result = create_instance<output_t, rank>(array.get_lengths());
      for (auto i = xtd::usize {0}; i < array.length(); ++i)
        result[i] = converter(array[i]);
      return result;
    }
    
    template<typename source_type_t, xtd::usize source_rank, typename source_allocator_t, typename destination_type_t, xtd::usize destination_rank, typename destination_allocator_t>
    static auto copy(const array<source_type_t, source_rank, source_allocator_t>& source_array, const array<destination_type_t, destination_rank, destination_allocator_t>& destination_array) -> void {copy(source_array, 0, destination_array, 0, destination_array.length());}
    template<typename source_type_t, xtd::usize source_rank, typename source_allocator_t, typename destination_type_t, xtd::usize destination_rank, typename destination_allocator_t>
    static auto copy(const array<source_type_t, source_rank, source_allocator_t>& source_array, const array<destination_type_t, destination_rank, destination_allocator_t>& destination_array, xtd::usize length) -> void {copy(source_array, 0, destination_array, 0, length);}
    template<typename source_type_t, xtd::usize source_rank, typename source_allocator_t, typename destination_type_t, xtd::usize destination_rank, typename destination_allocator_t>
    static auto copy(const array<source_type_t, source_rank, source_allocator_t>& source_array, const xtd::array<xtd::usize>& source_indexes, const array<destination_type_t, destination_rank, destination_allocator_t>& destination_array, const xtd::array<xtd::usize>& destination_indexes, xtd::usize length) -> void {
      copy(source_array, source_array.compute_index(source_array, source_indexes), destination_array, destination_array.compute_index(destination_array, destination_indexes), length);
    }

    template<typename source_type_t, xtd::usize source_rank, typename source_allocator_t, typename destination_type_t, xtd::usize destination_rank, typename destination_allocator_t>
    static auto copy(const array<source_type_t, source_rank, source_allocator_t>& source_array, xtd::usize source_index, const array<destination_type_t, destination_rank, destination_allocator_t>& destination_array, xtd::usize destination_index, xtd::usize length) -> void; // defined in as.hpp file
    
    template<typename type_t, typename allocator_t = xtd::collections::generic::helpers::allocator<type_t>>
    [[nodiscard]] static auto create_instance(xtd::usize length) -> xtd::array<type_t, 1, allocator_t> {return xtd::array<type_t, 1, allocator_t>(length);}
    template<typename type_t, typename allocator_t = xtd::collections::generic::helpers::allocator<type_t>>
    [[nodiscard]] static auto create_instance(xtd::usize length1, xtd::usize length2) -> xtd::array<type_t, 2, allocator_t> {return xtd::array<type_t, 2, allocator_t>(length1, length2);}
    template<typename type_t, typename allocator_t = xtd::collections::generic::helpers::allocator<type_t>>
    [[nodiscard]] static auto create_instance(xtd::usize length1, xtd::usize length2, xtd::usize length3) -> xtd::array<type_t, 3, allocator_t> {return xtd::array<type_t, 3, allocator_t>(length1, length2, length3);}
    template<typename type_t, xtd::usize rank, typename allocator_t = xtd::collections::generic::helpers::allocator<type_t>>
    [[nodiscard]] static auto create_instance(const xtd::array<xtd::usize>& lengths) -> xtd::array<type_t, rank, allocator_t> {return xtd::array<type_t, rank, allocator_t>(lengths, type_t {});}
    
    template<typename type_t, xtd::usize rank, typename allocator_t, typename predicate_t>
    [[nodiscard]] static auto exists(const xtd::array<type_t, rank, allocator_t>& array, predicate_t match) -> bool {
      for (const type_t& elem : array)
        if (match(elem)) return true;
      return false;
    }
    
    template<typename type_t, xtd::usize rank, typename allocator_t = xtd::collections::generic::helpers::allocator<type_t>>
    [[nodiscard]] static auto index_of(const xtd::array<type_t, rank, allocator_t>& array, const type_t& value) noexcept -> xtd::usize {return array.index_of(value);}
    template<typename type_t, xtd::usize rank, typename allocator_t = xtd::collections::generic::helpers::allocator<type_t>>
    [[nodiscard]] static auto index_of(const xtd::array<type_t, rank, allocator_t>& array, const type_t& value, xtd::usize index) -> xtd::usize {return array.index_of(value, index);}
    template<typename type_t, xtd::usize rank, typename allocator_t = xtd::collections::generic::helpers::allocator<type_t>>
    [[nodiscard]] static auto index_of(const xtd::array<type_t, rank, allocator_t>& array, const type_t& value, xtd::usize index, xtd::usize count) -> xtd::usize {
      return array.index_of(value, index, count);
    }
    
    template<typename type_t, typename allocator_t>
    static auto resize(xtd::array<type_t, 1, allocator_t>& array, int32 new_size) -> void {array.resize(new_size);}
    
    template<typename type_t, typename allocator_t>
    static auto reverse(xtd::array<type_t, 1, allocator_t>& array) -> void {array.reverse(0, array.length());}
    template<typename type_t, typename allocator_t>
    static auto reverse(xtd::array<type_t, 1, allocator_t>& array, int32 index, int32 count) -> void {array.reverse(index, count);}
  };
}