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]] auto equals(const object& obj) const noexcept -> bool override;
    [[nodiscard]] auto equals(const index& value) const noexcept -> bool override;
    
    [[nodiscard]] auto get_hash_code() const noexcept -> xtd::usize override;
    
    [[nodiscard]] auto get_offset(value_type length) const noexcept -> xtd::usize;
    
    [[nodiscard]] auto to_string() const noexcept -> xtd::string override;
    
    [[nodiscard]] constexpr auto to_usize() const noexcept -> value_type {return __v__;}
    
    auto operator ++() noexcept -> xtd::index&;
    auto operator --() noexcept -> xtd::index&;
    auto operator ++(int) noexcept -> xtd::index;
    auto operator --(int) noexcept -> xtd::index;
    constexpr auto operator ~() const noexcept -> xtd::index {return xtd::index {~__v__};}
    constexpr auto operator +() const noexcept -> xtd::index {return xtd::index {+__v__};}
    constexpr auto operator +(xtd::integer auto v) const noexcept -> xtd::index {return xtd::index {__v__ + static_cast<value_type>(v)};}
    constexpr auto operator -(xtd::integer auto v) const noexcept -> xtd::index {return xtd::index {__v__ - static_cast<value_type>(v)};}
    constexpr auto operator *(xtd::integer auto v) const noexcept -> xtd::index {return xtd::index {__v__ * static_cast<value_type>(v)};}
    constexpr auto operator /(xtd::integer auto v) const noexcept -> xtd::index {return xtd::index {__v__ / static_cast<value_type>(v)};}
    constexpr auto operator %(xtd::integer auto v) const noexcept -> xtd::index {return xtd::index {__v__ % static_cast<value_type>(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};}

    [[nodiscard]] static auto parse(const xtd::string& value) -> xtd::index;
    
    [[nodiscard]] static auto try_parse(const xtd::string& value, xtd::index& result) noexcept -> bool;

    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 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);
}