reference_guides/latest/raw__array_8hpp_source.html

#pragma once

#include <algorithm>

#include <cstdint>

#include <limits>

#include <vector>

#include "../../../forward_iterable.hpp"

#define __XTD_CORE_INTERNAL__

#include "../../../internal/__span_definitions.hpp"

#undef __XTD_CORE_INTERNAL__


namespace xtd {

  struct index;

  class range;


  namespace collections {

    namespace generic {

      namespace helpers {

        template<typename type_t, typename allocator_t = std::allocator<type_t>>


        class raw_array {

          using internal_storage_value_type = std::conditional_t<std::is_same_v<type_t, bool>, std::uint8_t, type_t>;

          using internal_storage_allocator_type = typename std::allocator_traits<allocator_t>::template rebind_alloc<internal_storage_value_type>;

          using internal_base_type = std::vector<internal_storage_value_type, internal_storage_allocator_type>;


          class internal_iterator {

          public:

            using iterator_base_type = typename internal_base_type::iterator;

            using iterator_category = std::random_access_iterator_tag;

            using value_type = type_t;

            using difference_type = std::ptrdiff_t;

            using pointer = type_t*;

            using reference = type_t&;


            internal_iterator() = default;

            explicit internal_iterator(iterator_base_type it) : it_(it) {}


            reference operator *() const {return reinterpret_cast<reference>(*it_);}

            pointer operator ->() const {return reinterpret_cast<pointer>(std::addressof(*it_));}


            internal_iterator& operator ++() {++it_; return *this;}

            internal_iterator operator ++(int) {internal_iterator tmp(*this); ++(*this); return tmp;}

            internal_iterator& operator --() {--it_; return *this;}

            internal_iterator operator --(int) {internal_iterator tmp(*this); --(*this); return tmp;}


            internal_iterator& operator +=(difference_type n) {it_ += n; return *this;}

            internal_iterator operator +(difference_type n) const {return internal_iterator(it_ + n);}

            internal_iterator& operator -=(difference_type n) {it_ -= n; return *this;}

            internal_iterator operator -(difference_type n) const {return internal_iterator(it_ - n);}

            difference_type operator -(const internal_iterator & other) const {return it_ - other.it_;}


            reference operator [](difference_type n) const {return reinterpret_cast<reference>(it_[n]);}


            bool operator ==(const internal_iterator & other) const {return it_ == other.it_;}

            bool operator !=(const internal_iterator & other) const {return it_ != other.it_;}

            bool operator <(const internal_iterator & other) const {return it_ <  other.it_;}

            bool operator <=(const internal_iterator & other) const {return it_ <= other.it_;}

            bool operator >(const internal_iterator & other) const {return it_ >  other.it_;}

            bool operator >=(const internal_iterator & other) const {return it_ >= other.it_;}


            iterator_base_type to_base_type() const {return it_;}


          private:

            friend class raw_array;

            iterator_base_type it_;

          };


          class internal_const_iterator {

          public:

            using iterator_base_type = typename internal_base_type::const_iterator;

            using iterator_category = std::random_access_iterator_tag;

            using value_type = const type_t;

            using difference_type = std::ptrdiff_t;

            using pointer = const type_t*;

            using reference = const type_t&;


            internal_const_iterator() = default;

            explicit internal_const_iterator(iterator_base_type it) : it_(it) {}

            internal_const_iterator(const internal_iterator & it) : it_(it.it_) {}


            reference operator*() const {return reinterpret_cast<reference>(*it_);}

            pointer operator->() const {return reinterpret_cast<pointer>(std::addressof(*it_));}


            internal_const_iterator& operator ++() {++it_; return *this;}

            internal_const_iterator operator ++(int) {internal_const_iterator tmp(*this); ++(*this); return tmp;}

            internal_const_iterator& operator --() {--it_; return *this;}

            internal_const_iterator operator --(int) {internal_const_iterator tmp(*this); --(*this); return tmp;}


            internal_const_iterator& operator +=(difference_type n) {it_ += n; return *this;}

            internal_const_iterator operator +(difference_type n) const {return internal_const_iterator(it_ + n);}

            internal_const_iterator& operator -=(difference_type n) {it_ -= n; return *this;}

            internal_const_iterator operator -(difference_type n) const {return internal_const_iterator(it_ - n);}

            difference_type operator -(const internal_const_iterator & other) const {return it_ - other.it_;}


            reference operator [](difference_type n) const { return reinterpret_cast<reference>(it_[n]);}


            bool operator ==(const internal_const_iterator & other) const {return it_ == other.it_;}

            bool operator !=(const internal_const_iterator & other) const {return it_ != other.it_;}

            bool operator <(const internal_const_iterator & other) const {return it_ <  other.it_;}

            bool operator <=(const internal_const_iterator & other) const {return it_ <= other.it_;}

            bool operator >(const internal_const_iterator & other) const {return it_ >  other.it_;}

            bool operator >=(const internal_const_iterator & other) const {return it_ >= other.it_;}


            iterator_base_type to_base_type() const {return it_;}


          private:

            friend class raw_array;

            iterator_base_type it_;

          };

        public:


          using value_type = type_t;

          using base_type = internal_base_type;

          using const_base_type = const base_type;

          using allocator_type = typename base_type::allocator_type;

          using size_type = std::size_t;

          using difference_type = std::ptrdiff_t;

          using reference = value_type&;

          using const_reference = const value_type&;

          using pointer = value_type*;

          using const_pointer = const value_type*;

          using iterator = internal_iterator;

          using const_iterator = internal_const_iterator;

          using reverse_iterator = std::reverse_iterator<iterator>;

          using const_reverse_iterator = std::reverse_iterator<const_iterator>;


          inline static constexpr size_type npos = std::numeric_limits<size_type>::max();


          raw_array() noexcept = default;

          explicit raw_array(const allocator_type & alloc) noexcept : items_(alloc) {}

          raw_array(size_type count, const type_t& value, const allocator_type& alloc = allocator_type()) : items_(count, value, alloc) {}

          explicit raw_array(size_type count, const allocator_type& alloc = allocator_type()) : items_(count, alloc) {}

          template<typename input_iterator_t>

          raw_array(input_iterator_t first, input_iterator_t last, const allocator_type& alloc = allocator_type()) : items_(first, last, alloc) {}

          raw_array(const raw_array & vector) : items_(vector.items_) {}

          raw_array(const base_type & vector) : items_(vector) {}

          raw_array(const raw_array & vector, const allocator_type & alloc) : items_(vector.items_, alloc) {}

          raw_array(const base_type & vector, const allocator_type & alloc) : items_(vector, alloc) {}

          raw_array(std::initializer_list<type_t> items, const allocator_type& alloc = allocator_type()) requires(!std::is_same_v<type_t, bool>) : items_(items, alloc) {}

          raw_array(std::initializer_list<bool> items, const allocator_type& alloc = allocator_type()) requires(std::is_same_v<type_t, bool>)  : items_(alloc) {

            items_.reserve(items.size());

            for (const auto& b : items)

              items_.push_back(b ? 1 : 0);

          }

          raw_array(raw_array&& other) : items_(std::move(other.items_)) {}

          raw_array(base_type&& other) : items_(std::move(other)) {}

          template<xtd::forward_iterable source_t>

          raw_array(source_t&& other) : items_(std::move(other)) {}

          raw_array(raw_array&& other, const allocator_type & alloc) : items_(std::move(other.items_), alloc) {}

          raw_array(base_type&& other, const allocator_type & alloc) : items_(std::move(other), alloc) {}


          [[nodiscard]] auto back() -> reference {return at(size() - 1);}

          [[nodiscard]] auto back() const -> const_reference {return at(size() - 1);}


          [[nodiscard]] auto begin() noexcept -> iterator {return to_type_iterator(items_.begin());}

          [[nodiscard]] auto begin() const noexcept -> const_iterator {return to_type_iterator(items_.cbegin());}


          [[nodiscard]] auto capacity() const noexcept -> size_type {return items_.capacity();}


          [[nodiscard]] auto cbegin() const noexcept -> const_iterator {return to_type_iterator(items_.cbegin());}

          [[nodiscard]] auto cend() const noexcept -> const_iterator {return to_type_iterator(items_.cend()); }


          [[nodiscard]] auto crbegin() const noexcept -> const_reverse_iterator {return const_reverse_iterator(end());}

          [[nodiscard]] auto crend() const noexcept -> const_reverse_iterator {return const_reverse_iterator(begin());}


          [[nodiscard]] auto data() noexcept -> pointer {return reinterpret_cast<pointer>(items_.data());}

          [[nodiscard]] auto data() const noexcept -> const_pointer {return reinterpret_cast<const_pointer>(items_.data());}


          [[nodiscard]] auto empty() const noexcept -> bool {return items_.empty();}


          [[nodiscard]] auto end() noexcept -> iterator {return to_type_iterator(items_.end());}

          [[nodiscard]] auto end() const noexcept -> const_iterator {return to_type_iterator(items_.cend());}


          [[nodiscard]] auto front() -> reference {return at(0);}

          [[nodiscard]] auto front() const -> const_reference {return at(0);}


          [[nodiscard]] auto items() const noexcept -> const_base_type& {return items_;}

          [[nodiscard]] auto items() noexcept -> base_type& {return items_;}


          [[nodiscard]] auto max_size() const noexcept -> size_type {return std::min(items_.max_size(), npos / 2);}


          [[nodiscard]] auto rbegin() noexcept -> reverse_iterator {return reverse_iterator(end());}

          [[nodiscard]] auto rbegin() const noexcept -> const_reverse_iterator {return const_reverse_iterator(end());}


          [[nodiscard]] auto rend() noexcept -> reverse_iterator {return reverse_iterator(begin());}

          [[nodiscard]] auto rend() const noexcept -> const_reverse_iterator {return const_reverse_iterator(begin());}


          [[nodiscard]] auto size() const noexcept -> size_type {return items_.size();}


          [[nodiscard]] auto version() const noexcept -> size_type {return version_;}


          auto assign(size_type count, const type_t& value) -> void {++version_; items_.assign(count, value);}

          template<typename input_iterator_t>

          auto assign(input_iterator_t first, input_iterator_t last) -> void {++version_; items_.assign(first, last);}

          auto assign(std::initializer_list<type_t> items) -> void {++version_; items_.assign(items.begin(), items.end());}


          auto at(size_type index) -> reference {return reinterpret_cast<reference>(items_.at(index > npos / 2 ? size() - (npos - index) : index));}

          auto at(size_type index) const -> const_reference {return reinterpret_cast<const_reference>(items_.at(index > npos / 2 ? size() - (npos - index) : index));}


          auto clear() -> void {++version_; items_.clear();}


          template<typename ...args_t>

          auto emplace(const_iterator pos, args_t&&... args) -> iterator {++version_; return to_type_iterator(items_.emplace(pos.to_base_type(), std::forward<args_t>(args)...));}

          template<typename ...args_t>

          auto emplace_back(args_t&&... args) -> reference {++version_; return reinterpret_cast<reference>(items_.emplace_back(std::forward<args_t>(args)...));}


          auto erase(const_iterator pos) -> iterator {++version_; return to_type_iterator(items_.erase(pos.to_base_type()));}

          auto erase(const_iterator first, const_iterator last) -> iterator {++version_; return to_type_iterator(items_.erase(first.to_base_type(), last.to_base_type()));}


          auto get_allocator() const -> allocator_type {return items_.get_allocator();}


          auto increment_version() noexcept -> size_type {return ++version_;}


          auto insert(const_iterator pos, const type_t& value) -> iterator {++version_; return to_type_iterator(items_.insert(pos.to_base_type(), value));}

          auto insert(const_iterator pos, type_t&& value) -> iterator {++version_; return to_type_iterator(items_.insert(pos.to_base_type(), std::move(value)));}

          auto insert(const_iterator pos, size_type count, const type_t& value) -> iterator {++version_; return to_type_iterator(items_.insert(pos.to_base_type(), count, value));}

          auto insert(const_iterator pos, size_type count, type_t&& value) -> iterator {++version_; return to_type_iterator(items_.insert(pos.to_base_type(), count, std::move(value)));}

          template<typename input_iterator_t>

          auto insert(const_iterator pos, input_iterator_t first, input_iterator_t last) -> iterator {++version_; return to_type_iterator(items_.insert(pos.to_base_type(), first, last));}

          auto insert(const_iterator pos, const std::initializer_list<type_t>& items) -> iterator {++version_; return to_type_iterator(items_.insert(pos.to_base_type(), items.begin(), items.end()));}


          auto pop_back() -> void {++version_; items_.pop_back();}

          auto push_back(const type_t& value) -> void {++version_; items_.push_back(value);}

          auto push_back(type_t&& value) -> void {++version_; items_.push_back(std::move(value));}


          auto reserve(size_type new_cap) -> void {++version_; items_.reserve(new_cap);}


          auto resize(size_type count) -> void {++version_; resize(count, value_type {});}

          auto resize(size_type count, const value_type & value) -> void {++version_; items_.resize(count, value);}


          auto shrink_to_fit() -> void {++version_; items_.shrink_to_fit();}


          auto swap(raw_array & other) noexcept -> void {++version_; items_.swap(other.items_);}


          auto operator =(const raw_array & other) -> raw_array& = default;

          auto operator =(raw_array&& other) noexcept -> raw_array&  = default;

          auto operator =(std::initializer_list<type_t>& items) -> raw_array& requires(!std::is_same_v<type_t, bool>) {

            ++version_;

            items_ = items;

            return *this;

          }

          auto operator =(std::initializer_list<bool>& items) -> raw_array& requires(std::is_same_v<type_t, bool>) {

            ++version_;

            items_.clear();

            items_.reserve(items.size());

            for (const auto& b : items)

              items_.push_back(b ? 1 : 0);

            return *this;

          }


          friend auto operator ==(const raw_array<type_t>& a, const raw_array<type_t>& b) -> bool {

            return a.items() == b.items();

          }

          friend auto operator ==(const raw_array<type_t>& a, const std::vector<type_t>& b) -> bool {

            return a.items() == b;

          }

          friend auto operator ==(const std::vector<type_t>& a, const raw_array<type_t>& b) -> bool {

            return a == b.items();

          }


          friend auto operator !=(const raw_array<type_t>& a, const raw_array<type_t>& b) -> bool {

            return a.items() != b.items();

          }

          friend auto operator !=(const raw_array<type_t>& a, const std::vector<type_t>& b) -> bool {

            return a.items() != b;

          }

          friend auto operator !=(const std::vector<type_t>& a, const raw_array<type_t>& b) -> bool {

            return a != b.items();

          }


          auto operator [](size_type index) const -> const_reference {return at(index);}

          auto operator [](size_type index) -> reference {return at(index);}

          auto operator [](const xtd::index& index) const -> const_reference;

          auto operator [](const xtd::index& index) -> reference;

          auto operator [](const xtd::range& range) const -> xtd::read_only_span<type_t>;

          auto operator [](const xtd::range& range) -> xtd::span<type_t>;


          auto operator ()(size_type index) const -> const_reference {return at(index);}

          auto operator ()(size_type index) -> reference {return at(index);}

          auto operator ()(const xtd::index& index) const -> const_reference;

          auto operator ()(const xtd::index& index) -> reference;

          auto operator ()(const xtd::range& range) const -> xtd::read_only_span<type_t>;

          auto operator ()(const xtd::range& range) -> xtd::span<type_t>;


          operator const base_type& () const noexcept {return items_;}

          operator base_type& () noexcept {return items_;}


        private:

          auto to_type_iterator(typename base_type::iterator it) -> iterator { return iterator(it); }

          auto to_type_iterator(typename base_type::const_iterator it) const -> const_iterator { return const_iterator(it); }


          base_type items_;

          size_type version_ = 0;

        };


        // Deduction guides for xtd::collections::generic::helpers::raw_array

        // {

        template<typename type_t>

        raw_array(std::initializer_list<type_t>) -> raw_array<type_t, std::allocator<type_t >>;


        template<typename type_t>

        raw_array(const std::vector<type_t>&) -> raw_array<type_t, std::allocator<type_t >>;


        template<typename type_t, typename allocator_t = std::allocator<type_t>>

        raw_array(const raw_array<type_t, allocator_t>&) -> raw_array<type_t, allocator_t>;


        template<typename type_t>

        raw_array(std::vector<type_t>&&) -> raw_array<type_t, std::allocator<type_t >>;


        template<typename type_t, typename allocator_t = std::allocator<type_t>>

        raw_array(raw_array<type_t, allocator_t>&&) -> raw_array<type_t, allocator_t>;

        // }

      }

    }

  }

}

__span_definitions.hpp

xtd::collections::generic::helpers::raw_array
Internal vector-like container used as a storage backend for xtd collections.
Definition raw_array.hpp:38

xtd::collections::generic::helpers::raw_array::const_reference
const value_type & const_reference
Const reference to element.
Definition raw_array.hpp:138

xtd::collections::generic::helpers::raw_array::raw_array
raw_array(size_type count, const allocator_type &alloc=allocator_type())
Create a new raw_array instance with specified count, and allocator.
Definition raw_array.hpp:169

xtd::collections::generic::helpers::raw_array::const_iterator
internal_const_iterator const_iterator
Const forward iterator for raw_array.
Definition raw_array.hpp:142

xtd::collections::generic::helpers::raw_array::difference_type
std::ptrdiff_t difference_type
Type used for differences between iterators.
Definition raw_array.hpp:136

xtd::collections::generic::helpers::raw_array::npos
static constexpr size_type npos
Represents an invalid index.
Definition raw_array.hpp:150

xtd::collections::generic::helpers::raw_array::raw_array
raw_array(size_type count, const type_t &value, const allocator_type &alloc=allocator_type())
Create a new raw_array instance with specified count, value, and allocator.
Definition raw_array.hpp:165

xtd::collections::generic::helpers::raw_array::base_type
internal_base_type base_type
Underlying vector type.
Definition raw_array.hpp:132

xtd::collections::generic::helpers::raw_array::iterator
internal_iterator iterator
Forward iterator for raw_array.
Definition raw_array.hpp:141

xtd::collections::generic::helpers::raw_array::pointer
value_type * pointer
Pointer to element.
Definition raw_array.hpp:139

xtd::collections::generic::helpers::raw_array::const_base_type
const base_type const_base_type
Const version of base_type.
Definition raw_array.hpp:133

xtd::collections::generic::helpers::raw_array::raw_array
raw_array(input_iterator_t first, input_iterator_t last, const allocator_type &alloc=allocator_type())
Create a new raw_array instance with specified first iterator, last iterator, and allocator.
Definition raw_array.hpp:175

xtd::collections::generic::helpers::raw_array::size_type
std::size_t size_type
Type used for sizes.
Definition raw_array.hpp:135

xtd::collections::generic::helpers::raw_array::reference
value_type & reference
Reference to element.
Definition raw_array.hpp:137

xtd::collections::generic::helpers::raw_array::const_reverse_iterator
std::reverse_iterator< const_iterator > const_reverse_iterator
Const reverse iterator.
Definition raw_array.hpp:144

xtd::collections::generic::helpers::raw_array::allocator_type
typename base_type::allocator_type allocator_type
Allocator type.
Definition raw_array.hpp:134

xtd::collections::generic::helpers::raw_array::value_type
type_t value_type
Type of the elements.
Definition raw_array.hpp:131

xtd::collections::generic::helpers::raw_array::reverse_iterator
std::reverse_iterator< iterator > reverse_iterator
Reverse iterator.
Definition raw_array.hpp:143

xtd::collections::generic::helpers::raw_array::raw_array
raw_array() noexcept=default
Create a new raw_array instance.

xtd::collections::generic::helpers::raw_array::const_pointer
const value_type * const_pointer
Const pointer to element.
Definition raw_array.hpp:140

xtd::range
Represents a range that has start and end indexes.
Definition range.hpp:28

forward_iterable.hpp
Contains xtd::forward_iterable concept.

xtd::platform_id::other
@ other
The operating system is other.
Definition platform_id.hpp:60

xtd::console_key::a
@ a
The A key.
Definition console_key.hpp:88

xtd::console_key::n
@ n
The N key.
Definition console_key.hpp:114

xtd::console_key::b
@ b
The B key.
Definition console_key.hpp:90

xtd::collections::generic::helpers
The xtd::collections::generic::helpers namespace contains helpers for generic collections,...
Definition allocator.hpp:14

xtd::collections::generic
The xtd::collections::generic namespace contains interfaces and classes that define generic collectio...
Definition comparer.hpp:16

xtd::collections
The xtd::collections namespace contains interfaces and classes that define various collections of obj...
Definition any_pair.hpp:10

xtd
The xtd namespace contains all fundamental classes to access Hardware, Os, System,...
Definition abstract_object.hpp:8

xtd::first
auto first() const -> read_only_span< type_t, count >
Obtains a subspan consisting of the first count elements of the sequence.
Definition read_only_span.hpp:263

xtd::empty
constexpr auto empty() const noexcept -> bool
Returns a value that indicates whether the current xtd::read_only_span <type_t> is empty.
Definition read_only_span.hpp:215

xtd::data
constexpr auto data() const noexcept -> const_pointer
Gets direct access to the underlying contiguous storage.
Definition read_only_span.hpp:211

xtd::last
auto last() const -> read_only_span< type_t, count >
Obtains a subspan consisting of the last N elements of the sequence.
Definition read_only_span.hpp:288

xtd::read_only_span
constexpr read_only_span()
Creates an empty xtd::read_only_span whose xtd::read_only_span::data is null and xtd::read_only_span:...
Definition read_only_span.hpp:89

xtd::size
constexpr auto size() const noexcept -> size_type
Returns the number of elements.
Definition read_only_span.hpp:231