index.hpp

Go to the documentation of this file.

#pragma once
#include "collections/generic/extensions/list_common.hpp"
#include "collections/generic/helpers/equator.hpp"
#include "collections/generic/helpers/raw_array.hpp"
#include "iequatable.hpp"
#include "integer.hpp"
#include "is.hpp"
#include "logical.hpp"
#include "object.hpp"
#include "usize.hpp"
#include "npos.hpp"

namespace xtd {
  struct index : public xtd::object, xtd::iequatable<index> {
    
    using value_type = xtd::usize;
    
    
    constexpr index() noexcept = default;
    constexpr index(xtd::integer auto value, xtd::logical auto from_end) noexcept : __v__{static_cast<value_type>(from_end ? ~value : value)} {}
    constexpr explicit index(xtd::integer auto value) noexcept : index {value, false} {}
    
    
    [[nodiscard]] constexpr auto value() const noexcept -> value_type {return is_from_end() ? ~__v__ : __v__;}
    
    [[nodiscard]] constexpr auto is_from_end() const noexcept -> bool {return __v__ > std::numeric_limits<value_type>::max() / 2;}
    
    [[nodiscard]] constexpr auto equals(const object& obj) const noexcept -> bool override {return is<index>(obj) && equals(static_cast<const index&>(obj));}
    [[nodiscard]] constexpr auto equals(const index& value) const noexcept -> bool override {return xtd::collections::generic::helpers::equator<value_type> {}(__v__, value.__v__);}
    
    [[nodiscard]] constexpr auto get_hash_code() const noexcept -> xtd::usize override {return hash_code::combine(__v__);}

    [[nodiscard]] constexpr auto get_offset(value_type length) const noexcept -> xtd::usize {return is_from_end() ? length - value() : value();}

    [[nodiscard]] auto to_string() const noexcept -> xtd::string override;
    
    operator value_type() {return __v__;}
    constexpr operator value_type() const {return __v__;}
    
    static const index end;

    static const index last;

    static const index start;
    
    inline static constexpr auto from_end(xtd::integer auto value) {return index {value, true};}

    inline static constexpr auto from_start(xtd::integer auto value) {return index {value};}

    value_type __v__ = value_type {0};
  };
}

inline constexpr const xtd::index xtd::index::end {0, true};
inline constexpr const xtd::index xtd::index::last {1, true};
inline constexpr const xtd::index xtd::index::start {0};
 
#include "literals/index.hpp"

template<typename type_t, typename allocator_t>
auto xtd::collections::generic::helpers::raw_array<type_t, allocator_t>::operator [](const xtd::index& index) const -> const_reference {return operator [](index.get_offset(size()));}
 
template<typename type_t, typename allocator_t>
auto xtd::collections::generic::helpers::raw_array<type_t, allocator_t>::operator [](const xtd::index& index) -> reference {return operator [](index.get_offset(size()));}
 
template<typename type_t, typename list_t>
auto xtd::collections::generic::extensions::list_common<type_t, list_t>::operator [](const xtd::index& index) const -> const type_t& {return self().operator [](index.get_offset(self().count()));}
 
template<typename type_t, typename list_t>
auto xtd::collections::generic::extensions::list_common<type_t, list_t>::operator [](const xtd::index& index) -> type_t& {return self().operator [](index.get_offset(self().count()));}
 
template<typename type_t, typename list_t>
auto xtd::collections::generic::extensions::list_common<type_t, list_t>::operator ()(const xtd::index& index) const -> const type_t& {return self().operator [](index);}
 
template<typename type_t, typename list_t>
auto xtd::collections::generic::extensions::list_common<type_t, list_t>::operator ()(const xtd::index& index) -> type_t& {
  return self().operator [](index);
}