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.h> 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>
    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>
    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>
    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);
    }
    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) {…}
    
    template<class type_t, class allocator_t>
    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>
    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>
    static void clear(const array<type_t, rank, allocator_t>& array) {
      clear(array, 0, array.data_->items.size());
    }
    static void clear(const array<type_t, rank, allocator_t>& array) {…}
    
    template<class type_t, xtd::size rank, class allocator_t>
    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 i = xtd::size {}; i < length; ++i)
        array.data_->items[index + i] = type_t {};
    }
    static void clear(const array<type_t, rank, allocator_t>& array, xtd::size index, xtd::size 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 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);
    }
    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) {…}
    
    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 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
    
  };
  class array<> static_ {…};
}