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

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

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

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