//! \addtogroup Containers //! \{ //! \file pivector.h //! \brief //! \~english Declares \a PIVector //! \~russian Объявление \a PIVector //! \~\authors //! \~english //! Ivan Pelipenko peri4ko@yandex.ru; //! Andrey Bychkov work.a.b@yandex.ru; //! \~russian //! Иван Пелипенко peri4ko@yandex.ru; //! Андрей Бычков work.a.b@yandex.ru; //! \~\} /* PIP - Platform Independent Primitives Sequence linear container aka dynamic size array of any type Ivan Pelipenko peri4ko@yandex.ru, Andrey Bychkov work.a.b@yandex.ru This program is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this program. If not, see . */ #ifndef PIVECTOR_H #define PIVECTOR_H #include "picontainers.h" //! \addtogroup Containers //! \{ //! \class PIVector //! \brief //! \~english Sequence linear container - dynamic size array of any type. //! \~russian Последовательный контейнер с линейной памятью - динамический массив любого типа. //! \~\} //! \details //! \~english //! The elements are stored contiguously, //! which means that elements can be accessed not only through iterators, //! but also using offsets to regular pointers to elements. //! This means that a pointer to an element of a PIVector may be passed to any function //! that expects a pointer to an element of an array. //! To add elements you can use functions \a append() and \a insert(), //! to remove elements you can use functions \a remove() and \a removeOne(), \a removeWhere(). //! Change size by function \a resize() and \a assign(). //! Items in an array are numbered, starting from zero. //! This number is called the item's index. //! So the first item has index 0, the last has index `size() - 1`. //! A set of various convenient functions is also available for the array, //! for example: \a indexOf(), \a contains(), \a entries(), \a isEmpty(), \a isNotEmpty(), //! \a every(), \a any(), \a forEach(), \a indexWhere(), \a getRange(), \a sort(), //! \a map(), \a reduce(), \a filter(), \a flatten(), \a reshape() and others. //! //! The storage of the PIVector is handled automatically, //! being expanded as needed. //! PIVector usually occupy more space than static arrays, //! because more memory is allocated to handle future growth. //! This way a PIVector does not need to reallocate each time an element is inserted, //! but only when the additional memory is exhausted. //! The total amount of allocated memory can be queried using \a capacity() function. //! Reallocations are usually costly operations in terms of performance. //! The \a reserve() function can be used to eliminate reallocations //! if the number of elements is known beforehand. //! //! The complexity (efficiency) of common operations on PIVector is as follows: //! - Random access - constant O(1) //! - Insertion or removal of elements at the end - amortized constant O(1) //! - Insertion or removal of elements - linear in the distance to the end of the array O(n) //! //! \~russian //! Элементы хранятся непрерывно, а значит доступны не только через итераторы, //! но и с помощью смещений для обычных указателей на элементы. //! Это означает, что указатель на элемент PIVector может передаваться в любую функцию, //! ожидающую указатель на элемент массива. //! Добавить элементы можно с помощью функции \a append() или \a insert(), //! а удалить с помощью \a remove() или \a removeOne(), \a removeWhere(). //! Изменить размер можно функцией \a resize() или \a assign(). //! Массив индексируется с нуля: //! первый элемент массива имеет индекс, равный `0`, //! а индекс последнего элемента равен `size() - 1`. //! Также для массива доступен набор различных удобных функций, //! например: \a indexOf(), \a contains(), \a entries(), \a isEmpty(), \a isNotEmpty(), //! \a every(), \a any(), \a forEach(), \a indexWhere(), \a getRange(), \a sort(), //! \a map(), \a reduce(), \a filter(), \a flatten(), \a reshape() и другие. //! //! Память PIVector обрабатывается автоматически, //! расширяясь по мере необходимости. //! Векторы обычно занимают больше места, чем статические массивы, //! поскольку больше памяти выделяется для обработки будущего роста. //! Таким образом, память для PIVector требуется выделять //! не при каждой вставке элемента, //! а только после исчерпания дополнительной памяти. //! Общий объём выделенной памяти можно получить с помощью функции \a capacity(). //! //! Выделение памяти обычно является дорогостоящей операцией //! с точки зрения производительности. //! Функцию \a reserve() можно использовать для исключения выделения памяти, //! если количество элементов известно заранее. //! //! Сложность (эффективность) обычных операций над PIVector следующая: //! - Произвольный доступ — постоянная O(1) //! - Вставка и удаление элементов в конце — амортизированная постоянная O(1) //! - Вставка и удаление элементов — линейная по расстоянию до конца массива O(n) //! //! \~\sa \a PIDeque, \a PIMap template class PIVector { public: typedef bool (*CompareFunc)(const T &, const T &); typedef T value_type; typedef T * pointer; typedef const T * const_pointer; typedef T & reference; typedef const T & const_reference; typedef size_t size_type; //! \~english Constructs an empty array. //! \~russian Создает пустой массив. inline PIVector() { PIINTROSPECTION_CONTAINER_NEW(T, sizeof(T)) } //! \~english Contructs array from raw `data`. //! This constructor reserve `size` and copy from `data` pointer. //! \~russian Создает массив из указателя на данные `data` и размер `size`. //! То есть выделяет память для `size` элементов и копирует данные из указателя `data`. inline PIVector(const T * data, size_t size) { PIINTROSPECTION_CONTAINER_NEW(T, sizeof(T)) alloc(size); newT(piv_data, data, piv_size); } //! \~english Copy constructor. //! \~russian Копирующий конструктор. inline PIVector(const PIVector & v) { PIINTROSPECTION_CONTAINER_NEW(T, sizeof(T)) alloc(v.piv_size); newT(piv_data, v.piv_data, piv_size); } //! \~english Contructs array from //! [C++11 initializer list](https://en.cppreference.com/w/cpp/utility/initializer_list). //! \~russian Создает массив из //! [списка инициализации C++11](https://ru.cppreference.com/w/cpp/utility/initializer_list). //! \~\details //! \~\code //! PIVector v{1,2,3}; //! piCout << v; // {1, 2, 3} //! \endcode inline PIVector(std::initializer_list init_list) { PIINTROSPECTION_CONTAINER_NEW(T, sizeof(T)) alloc(init_list.size()); newT(piv_data, init_list.begin(), init_list.size()); } //! \~english Contructs array with size `size` filled elements `e`. //! \~russian Создает массив из `size` элементов заполненных `e`. inline explicit PIVector(size_t size, const T & e = T()) { PIINTROSPECTION_CONTAINER_NEW(T, sizeof(T)) expand(size, e); } //! \~english Contructs array with size `size` and elements created by function `f(size_t i)`. //! \~russian Создает массив из `size` элементов созданных функцией `f(size_t i)`. //! \~\details //! \~english Can use //! [Lambda expressions](https://en.cppreference.com/w/cpp/language/lambda) //! as constructor argument. //! \~russian Позволяет передавать //! [Лямбда-выражения](https://ru.cppreference.com/w/cpp/language/lambda) //! для создания элементов в конструкторе. //! \~\code //! PIVector v(5, [](size_t i){return i*2;}); //! piCout << v; // {0, 2, 4, 6, 8} //! \endcode inline PIVector(size_t size, std::function f) { PIINTROSPECTION_CONTAINER_NEW(T, sizeof(T)) expand(size, f); } //! \~english Move constructor. //! \~russian Перемещающий конструктор. inline PIVector(PIVector && v) { PIINTROSPECTION_CONTAINER_NEW(T, sizeof(T)) piv_data = v.piv_data; piv_size = v.piv_size; piv_rsize = v.piv_rsize; v._reset(); } inline ~PIVector() { PIINTROSPECTION_CONTAINER_DELETE(T) PIINTROSPECTION_CONTAINER_FREE(T, (piv_rsize)) deleteT(piv_data, piv_size); dealloc(); } //! \~english Assign operator. //! \~russian Оператор присваивания. inline PIVector & operator=(const PIVector & v) { if (this == &v) return *this; clear(); alloc(v.piv_size); newT(piv_data, v.piv_data, piv_size); return *this; } //! \~english Assign move operator. //! \~russian Оператор перемещающего присваивания. inline PIVector & operator=(PIVector && v) { swap(v); return *this; } class iterator { friend class PIVector; private: inline iterator(PIVector * v, ssize_t p): parent(v), pos(p) {} PIVector * parent; ssize_t pos; public: typedef T value_type; typedef T * pointer; typedef T & reference; typedef std::ptrdiff_t difference_type; typedef std::random_access_iterator_tag iterator_category; inline iterator(): parent(0), pos(0) {} inline T & operator*() { return (*parent)[pos]; } inline const T & operator*() const { return (*parent)[pos]; } inline T & operator->() { return (*parent)[pos]; } inline const T & operator->() const { return (*parent)[pos]; } inline iterator & operator++() { ++pos; return *this; } inline iterator operator++(int) { const auto tmp = *this; ++*this; return tmp; } inline iterator & operator--() { --pos; return *this; } inline iterator operator--(int) { const auto tmp = *this; --*this; return tmp; } inline iterator & operator+=(const iterator & it) { pos += it.pos; return *this; } inline iterator & operator+=(size_t p) { pos += p; return *this; } inline iterator & operator-=(const iterator & it) { pos -= it.pos; return *this; } inline iterator & operator-=(size_t p) { pos -= p; return *this; } friend inline iterator operator-(size_t p, const iterator & it) { return it - p; } friend inline iterator operator-(const iterator & it, size_t p) { auto tmp = it; tmp -= p; return tmp; } friend inline std::ptrdiff_t operator-(const iterator & it1, const iterator & it2) { return it1.pos - it2.pos; } friend inline iterator operator+(size_t p, const iterator & it) { return it + p; } friend inline iterator operator+(const iterator & it, size_t p) { auto tmp = it; tmp += p; return tmp; } inline bool operator==(const iterator & it) const { return (pos == it.pos); } inline bool operator!=(const iterator & it) const { return (pos != it.pos); } friend inline bool operator<(const iterator & it1, const iterator & it2) { return it1.pos < it2.pos; } friend inline bool operator<=(const iterator & it1, const iterator & it2) { return it1.pos <= it2.pos; } friend inline bool operator>(const iterator & it1, const iterator & it2) { return it1.pos > it2.pos; } friend inline bool operator>=(const iterator & it1, const iterator & it2) { return it1.pos >= it2.pos; } }; class const_iterator { friend class PIVector; private: inline const_iterator(const PIVector * v, ssize_t p): parent(v), pos(p) {} const PIVector * parent; ssize_t pos; public: typedef T value_type; typedef T * pointer; typedef T & reference; typedef std::ptrdiff_t difference_type; typedef std::random_access_iterator_tag iterator_category; inline const_iterator(): parent(0), pos(0) {} inline const T & operator*() const { return (*parent)[pos]; } inline const T & operator->() const { return (*parent)[pos]; } inline const_iterator & operator++() { ++pos; return *this; } inline const_iterator operator++(int) { const auto tmp = *this; ++*this; return tmp; } inline const_iterator & operator--() { --pos; return *this; } inline const_iterator operator--(int) { const auto tmp = *this; --*this; return tmp; } inline const_iterator & operator+=(const const_iterator & it) { pos += it.pos; return *this; } inline const_iterator & operator+=(size_t p) { pos += p; return *this; } inline const_iterator & operator-=(const const_iterator & it) { pos -= it.pos; return *this; } inline const_iterator & operator-=(size_t p) { pos -= p; return *this; } friend inline const_iterator operator-(size_t p, const const_iterator & it) { return it - p; } friend inline const_iterator operator-(const const_iterator & it, size_t p) { auto tmp = it; tmp -= p; return tmp; } friend inline std::ptrdiff_t operator-(const const_iterator & it1, const const_iterator & it2) { return it1.pos - it2.pos; } friend inline const_iterator operator+(size_t p, const const_iterator & it) { return it + p; } friend inline const_iterator operator+(const const_iterator & it, size_t p) { auto tmp = it; tmp += p; return tmp; } inline bool operator==(const const_iterator & it) const { return (pos == it.pos); } inline bool operator!=(const const_iterator & it) const { return (pos != it.pos); } friend inline bool operator<(const const_iterator & it1, const const_iterator & it2) { return it1.pos < it2.pos; } friend inline bool operator<=(const const_iterator & it1, const const_iterator & it2) { return it1.pos <= it2.pos; } friend inline bool operator>(const const_iterator & it1, const const_iterator & it2) { return it1.pos > it2.pos; } friend inline bool operator>=(const const_iterator & it1, const const_iterator & it2) { return it1.pos >= it2.pos; } }; class reverse_iterator { friend class PIVector; private: inline reverse_iterator(PIVector * v, ssize_t p): parent(v), pos(p) {} PIVector * parent; ssize_t pos; public: typedef T value_type; typedef T * pointer; typedef T & reference; typedef std::ptrdiff_t difference_type; typedef std::random_access_iterator_tag iterator_category; inline reverse_iterator(): parent(0), pos(0) {} inline T & operator*() { return (*parent)[pos]; } inline const T & operator*() const { return (*parent)[pos]; } inline T & operator->() { return (*parent)[pos]; } inline const T & operator->() const { return (*parent)[pos]; } inline reverse_iterator & operator++() { --pos; return *this; } inline reverse_iterator operator++(int) { const auto tmp = *this; --*this; return tmp; } inline reverse_iterator & operator--() { ++pos; return *this; } inline reverse_iterator operator--(int) { const auto tmp = *this; ++*this; return tmp; } inline reverse_iterator & operator+=(const reverse_iterator & it) { pos -= it.pos; return *this; } inline reverse_iterator & operator+=(size_t p) { pos -= p; return *this; } inline reverse_iterator & operator-=(const reverse_iterator & it) { pos += it.pos; return *this; } inline reverse_iterator & operator-=(size_t p) { pos += p; return *this; } friend inline reverse_iterator operator-(size_t p, const reverse_iterator & it) { return it - p; } friend inline reverse_iterator operator-(const reverse_iterator & it, size_t p) { auto tmp = it; tmp -= p; return tmp; } friend inline std::ptrdiff_t operator-(const reverse_iterator & it1, const reverse_iterator & it2) { return it2.pos - it1.pos; } friend inline reverse_iterator operator+(size_t p, const reverse_iterator & it) { return it + p; } friend inline reverse_iterator operator+(const reverse_iterator & it, size_t p) { auto tmp = it; tmp += p; return tmp; } inline bool operator==(const reverse_iterator & it) const { return (pos == it.pos); } inline bool operator!=(const reverse_iterator & it) const { return (pos != it.pos); } friend inline bool operator<(const reverse_iterator & it1, const reverse_iterator & it2) { return it1.pos < it2.pos; } friend inline bool operator<=(const reverse_iterator & it1, const reverse_iterator & it2) { return it1.pos <= it2.pos; } friend inline bool operator>(const reverse_iterator & it1, const reverse_iterator & it2) { return it1.pos > it2.pos; } friend inline bool operator>=(const reverse_iterator & it1, const reverse_iterator & it2) { return it1.pos >= it2.pos; } }; class const_reverse_iterator { friend class PIVector; private: inline const_reverse_iterator(const PIVector * v, ssize_t p): parent(v), pos(p) {} const PIVector * parent; ssize_t pos; public: typedef T value_type; typedef T * pointer; typedef T & reference; typedef std::ptrdiff_t difference_type; typedef std::random_access_iterator_tag iterator_category; inline const_reverse_iterator(): parent(0), pos(0) {} inline const T & operator*() const { return (*parent)[pos]; } inline const T & operator->() const { return (*parent)[pos]; } inline const_reverse_iterator & operator++() { --pos; return *this; } inline const_reverse_iterator operator++(int) { const auto tmp = *this; --*this; return tmp; } inline const_reverse_iterator & operator--() { ++pos; return *this; } inline const_reverse_iterator operator--(int) { const auto tmp = *this; ++*this; return tmp; } inline const_reverse_iterator & operator+=(const const_reverse_iterator & it) { pos -= it.pos; return *this; } inline const_reverse_iterator & operator+=(size_t p) { pos -= p; return *this; } inline const_reverse_iterator & operator-=(const const_reverse_iterator & it) { pos += it.pos; return *this; } inline const_reverse_iterator & operator-=(size_t p) { pos += p; return *this; } friend inline const_reverse_iterator operator-(size_t p, const const_reverse_iterator & it) { return it - p; } friend inline const_reverse_iterator operator-(const const_reverse_iterator & it, size_t p) { auto tmp = it; tmp -= p; return tmp; } friend inline std::ptrdiff_t operator-(const const_reverse_iterator & it1, const const_reverse_iterator & it2) { return it2.pos - it1.pos; } friend inline const_reverse_iterator operator+(size_t p, const const_reverse_iterator & it) { return it + p; } friend inline const_reverse_iterator operator+(const const_reverse_iterator & it, size_t p) { auto tmp = it; tmp += p; return tmp; } inline bool operator==(const const_reverse_iterator & it) const { return (pos == it.pos); } inline bool operator!=(const const_reverse_iterator & it) const { return (pos != it.pos); } friend inline bool operator<(const const_reverse_iterator & it1, const const_reverse_iterator & it2) { return it1.pos < it2.pos; } friend inline bool operator<=(const const_reverse_iterator & it1, const const_reverse_iterator & it2) { return it1.pos <= it2.pos; } friend inline bool operator>(const const_reverse_iterator & it1, const const_reverse_iterator & it2) { return it1.pos > it2.pos; } friend inline bool operator>=(const const_reverse_iterator & it1, const const_reverse_iterator & it2) { return it1.pos >= it2.pos; } }; //! \~english Iterator to the first element. //! \~russian Итератор на первый элемент. //! \~\details ![begin, end](doc/images/pivector_begin.png) //! //! \~english If the array is empty, the returned iterator is equal to \a end(). //! \~russian Если массив пустой, возвращаемый итератор будет равен \a end(). //! \~\return \ref stl_iterators //! \~\sa \a end(), \a rbegin(), \a rend() inline iterator begin() { return iterator(this, 0); } //! \~english Iterator to the element following the last element. //! \~russian Итератор на элемент, следующий за последним элементом. //! \~\details ![begin, end](doc/images/pivector_begin.png) //! //! \~english This element acts as a placeholder; //! attempting to access it results in undefined behavior. //! \~russian Этот элемент существует лишь условно, //! попытка доступа к нему приведёт к выходу за разрешенную память. //! \~\return \ref stl_iterators //! \~\sa \a begin(), \a rbegin(), \a rend() inline iterator end() { return iterator(this, piv_size); } inline const_iterator begin() const { return const_iterator(this, 0); } inline const_iterator end() const { return const_iterator(this, piv_size); } //! \~english Returns a reverse iterator to the first element of the reversed array. //! \~russian Обратный итератор на первый элемент. //! \~\details ![rbegin, rend](doc/images/pivector_rbegin.png) //! //! \~english It corresponds to the last element of the non-reversed array. //! If the array is empty, the returned iterator is equal to \a rend(). //! \~russian Итератор для прохода массива в обратном порядке. //! Указывает на последний элемент. //! Если массив пустой, то совпадает с итератором \a rend(). //! \~\return \ref stl_iterators //! \~\sa \a rend(), \a begin(), \a end() inline reverse_iterator rbegin() { return reverse_iterator(this, piv_size - 1); } //! \~english Returns a reverse iterator to the element //! following the last element of the reversed array. //! \~russian Обратный итератор на элемент, следующий за последним элементом. //! \~\details ![rbegin, rend](doc/images/pivector_rbegin.png) //! //! \~english It corresponds to the element preceding the first element of the non-reversed array. //! This element acts as a placeholder, attempting to access it results in undefined behavior. //! \~russian Итератор для прохода массива в обратном порядке. //! Указывает на элемент, предшествующий первому элементу. //! Этот элемент существует лишь условно, //! попытка доступа к нему приведёт к выходу за разрешенную память. //! \~\return \ref stl_iterators //! \~\sa \a rbegin(), \a begin(), \a end() inline reverse_iterator rend() { return reverse_iterator(this, -1); } inline const_reverse_iterator rbegin() const { return const_reverse_iterator(this, piv_size - 1); } inline const_reverse_iterator rend() const { return const_reverse_iterator(this, -1); } //! \~english Number of elements in the container. //! \~russian Количество элементов массива. //! \~\sa \a size_s(), \a capacity(), \a isEmpty(), \a isNotEmpty(), \a resize(), \a reserve() inline size_t size() const { return piv_size; } //! \~english Number of elements in the container as signed value. //! \~russian Количество элементов массива в виде знакового числа. //! \~\sa \a size(), \a capacity(), \a isEmpty(), \a isNotEmpty(), \a resize(), \a reserve() inline ssize_t size_s() const { return piv_size; } //! \~english Same as \a size(). //! \~russian Синоним \a size(). //! \~\sa \a size(), \a size_s(), \a capacity(), \a isEmpty(), \a isNotEmpty(), \a resize(), \a reserve() inline size_t length() const { return piv_size; } //! \~english Number of elements that the container has currently allocated space for. //! \~russian Количество элементов, для которого сейчас выделена память массивом. //! \~\details //! \~english To find out the actual number of items, use the function \a size(). //! \~russian Чтобы узнать фактическое количество элементов используйте функцию \a size(). //! \~\sa \a reserve(), \a size(), \a size_s() inline size_t capacity() const { return piv_rsize; } //! \~english Checks if the container has no elements. //! \~russian Проверяет пуст ли массив. //! \~\return //! \~english **true** if the container is empty, **false** otherwise //! \~russian **true** если массив пуст, **false** иначе. //! \~\sa \a size(), \a size_s(), \a isEmpty(), \a isNotEmpty(), \a resize(), \a reserve() inline bool isEmpty() const { return (piv_size == 0); } //! \~english Checks if the container has elements. //! \~russian Проверяет не пуст ли массив. //! \~\return //! \~english **true** if the container is not empty, **false** otherwise //! \~russian **true** если массив не пуст, **false** иначе. //! \~\sa \a size(), \a size_s(), \a isEmpty(), \a isNotEmpty(), \a resize(), \a reserve() inline bool isNotEmpty() const { return (piv_size > 0); } //! \~english Tests whether at least one element in the array //! passes the test implemented by the provided function `test`. //! \~russian Проверяет, удовлетворяет ли какой-либо элемент массива условию, //! заданному в передаваемой функции `test`. //! \~\return //! \~english **true** if, in the array, //! it finds an element for which the provided function returns **true**; //! otherwise it returns **false**. Always returns **false** if is empty. //! \~russian **true** если хотя бы для одного элемента //! передаваемая функция возвращает **true**, в остальных случаях **false**. //! Метод возвращает **false** при любом условии для пустого массива. //! \~\details //! \~\code //! PIVector v{1, 2, 8, 9}; //! piCout << v.any([](int e){return e % 2 == 0;}); // true //! piCout << v.any([](int e){return e == 3;}); // false //! \endcode //! \~\sa \a every(), \a contains(), \a entries(), \a forEach() inline bool any(std::function test) const { for (size_t i = 0; i < piv_size; ++i) { if (test(piv_data[i])) return true; } return false; } //! \~english Tests whether all elements in the array passes the test //! implemented by the provided function `test`. //! \~russian Проверяет, удовлетворяют ли все элементы массива условию, //! заданному в передаваемой функции `test`. //! \~\return //! \~english **true** if, in the array, //! it finds an element for which the provided function returns **true**; //! otherwise it returns **false**. Always returns **true** if is empty. //! \~russian **true** если для всех элементов передаваемая функция возвращает **true**, //! в остальных случаях **false**. //! Метод возвращает **true** при любом условии для пустого массива. //! \~\details //! \~\code //! PIVector v{1, 2, 8, 9}; //! piCout << v.every([](int e){return e % 2 == 0;}); // false //! piCout << v.every([](int e){return e > 0;}); // true //! \endcode //! \~\sa \a any(), \a contains(), \a entries(), \a forEach() inline bool every(std::function test) const { for (size_t i = 0; i < piv_size; ++i) { if (!test(piv_data[i])) return false; } return true; } //! \~english Full access to element by `index`. //! \~russian Полный доступ к элементу по индексу `index`. //! \~\details //! \~english Element index starts from `0`. //! Element index must be in range from `0` to `size()-1`. //! Otherwise will be undefined behavior. //! \~russian Индекс элемента считается от `0`. //! Индекс элемента должен лежать в пределах от `0` до `size()-1`. //! Иначе это приведёт к неопределённому поведению программы и ошибкам памяти. //! \~\code //! PIVector v{1, 2, 8, 9}; //! piCout << v[2]; // 8 //! v[2] = 5; //! piCout << v; // {1, 2, 5, 9} //! \endcode //! \~\sa \a at() inline T & operator[](size_t index) { return piv_data[index]; } inline const T & operator[](size_t index) const { return piv_data[index]; } //! \~english Read only access to element by `index`. //! \~russian Доступ исключительно на чтение к элементу по индексу `index`. //! \~\details //! \~english Element index starts from `0`. //! Element index must be in range from `0` to `size()-1`. //! Otherwise will be undefined behavior. //! \~russian Индекс элемента считается от `0`. //! Индекс элемента должен лежать в пределах от `0` до `size()-1`. //! Иначе это приведёт к неопределённому поведению программы и ошибкам памяти. inline const T & at(size_t index) const { return piv_data[index]; } //! \~english Returns the first element of the array that //! passes the test implemented by the provided function `test` //! or `def` if there is no such element. //! \~russian Возвращает первый элемент массива, проходящего по условию, //! заданному в передаваемой функции `test`, или `def` если такого элемента нет. //! \~\sa \a indexWhere() inline const T & atWhere(std::function test, ssize_t start = 0, const T & def = T()) const { const ssize_t i = indexWhere(test, start); if (i < 0) return def; else return at(i); } //! \~english Returns the last element of the array that //! passes the test implemented by the provided function `test` //! or `def` if there is no such element. //! \~russian Возвращает последний элемент массива, проходящего по условию, //! заданному в передаваемой функции `test`, или `def` если такого элемента нет. //! \~\sa \a lastIndexWhere() inline const T & lastAtWhere(std::function test, ssize_t start = -1, const T & def = T()) const { const ssize_t i = lastIndexWhere(test, start); if (i < 0) return def; else return at(i); } //! \~english Last element. //! \~russian Последний элемент массива. //! \~\details //! \~english Returns a reference to the last item in the array. //! This function assumes that the array isn't empty. //! Otherwise will be undefined behavior. //! \~russian Возвращает ссылку на последний элемент в массиве. //! Эта функция предполагает, что массив не пустой. //! Иначе это приведёт к неопределённому поведению программы и ошибкам памяти. inline T & back() { return piv_data[piv_size - 1]; } inline const T & back() const { return piv_data[piv_size - 1]; } //! \~english Last element. //! \~russian Первый элемент массива. //! \~\details //! \~english Returns a reference to the last item in the array. //! This function assumes that the array isn't empty. //! Otherwise will be undefined behavior. //! \~russian Возвращает ссылку на пенрвый элемент в массиве. //! Эта функция предполагает, что массив не пустой. //! Иначе это приведёт к неопределённому поведению программы и ошибкам памяти. inline T & front() { return piv_data[0]; } inline const T & front() const { return piv_data[0]; } //! \~english Compare operator with array `v`. //! \~russian Оператор сравнения с массивом `v`. inline bool operator==(const PIVector & v) const { if (piv_size != v.piv_size) return false; for (size_t i = 0; i < piv_size; ++i) { if (v[i] != piv_data[i]) return false; } return true; } //! \~english Compare operator with array `v`. //! \~russian Оператор сравнения с массивом `v`. inline bool operator!=(const PIVector & v) const { return !(*this == v); } //! \~english Tests if element `e` exists in the array. //! \~russian Проверяет наличие элемента `e` в массиве. //! \~\details //! \~english Optional argument `start` - the position in this array at which to begin searching. //! If the index is greater than or equal to the array's size, //! **false** is returned, which means the array will not be searched. //! If the provided index value is a negative number, //! it is taken as the offset from the end of the array. //! Note: if the provided index is negative, //! the array is still searched from front to back. //! Default: 0 (entire array is searched). //! \~russian Опциональный аргумент `start` указывает на индекс в массиве, откуда будет начинаться поиск. //! Если индекс больше или равен длине массива, //! возвращается **false**, что означает, что массив даже не просматривается. //! Если индекс является отрицательным числом, он трактуется как смещение с конца массива. //! Если рассчитанный индекс все равно оказывается меньше 0, просматривается весь массив. //! Обратите внимание: если индекс отрицателен, массив всё равно просматривается от начала к концу (слева на право). //! Значение по умолчанию равно 0, что означает, что просматривается весь массив. //! \~\code //! PIVector v{1, 2, 3, 4}; //! piCout << v.contains(3); // true //! piCout << v.contains(5); // false //! piCout << v.contains(3, 3); // false //! piCout << v.contains(3, -2); // true //! piCout << v.contains(3, -99); // true //! \endcode //! \~\return //! \~english **true** if the array contains an occurrence of element `e`, //! otherwise it returns **false**. //! \~russian **true** если элемент `e` присутствует в массиве, //! в остальных случаях **false**. //! \~\sa \a every(), \a any(), \a entries(), \a forEach() inline bool contains(const T & e, ssize_t start = 0) const { if (start < 0) { start = piv_size + start; if (start < 0) start = 0; } for (size_t i = start; i < piv_size; ++i) { if (e == piv_data[i]) return true; } return false; } //! \~english Tests if all elements of `v` exists in the array. //! \~russian Проверяет наличие всех элементов `v` в массиве. //! \~\details //! \~\code //! PIVector v{1, 2, 3, 4}; //! piCout << v.contains({1,4}); // true //! piCout << v.contains({1,5}); // false //! \endcode //! \~\sa \a every(), \a any(), \a entries(), \a forEach() inline bool contains(const PIVector & v, ssize_t start = 0) const { if (start < 0) { start = piv_size + start; if (start < 0) start = 0; } for (const T & e: v) { bool c = false; for (size_t i = start; i < piv_size; ++i) { if (e == piv_data[i]) { c = true; break; } } if (!c) return false; } return true; } //! \~english Count elements equal `e` in the array. //! \~russian Подсчитывает количество элементов, совпадающих с элементом `e` в массиве. //! \~\details //! \~english Optional argument `start` - the position in this array at which to begin searching. //! If the index is greater than or equal to the array's size, //! 0 is returned, which means the array will not be searched. //! If the provided index value is a negative number, //! it is taken as the offset from the end of the array. //! Note: if the provided index is negative, //! the array is still searched from front to back. //! Default: 0 (entire array is searched). //! \~russian Опциональный аргумент `start` указывает на индекс в массиве, откуда будет начинаться поиск. //! Если индекс больше или равен длине массива, //! возвращается 0, что означает, что массив даже не просматривается. //! Если индекс является отрицательным числом, он трактуется как смещение с конца массива. //! Если рассчитанный индекс все равно оказывается меньше 0, просматривается весь массив. //! Обратите внимание: если индекс отрицателен, массив всё равно просматривается от начала к концу (слева на право). //! Значение по умолчанию равно 0, что означает, что просматривается весь массив. //! \~\code //! PIVector v{2, 2, 4, 2, 6}; //! piCout << v.entries(2); // 3 //! piCout << v.entries(2, 2); // 1 //! piCout << v.entries(2, -4); // 2 //! \endcode //! \~\sa \a every(), \a any(), \a contains(), \a forEach(), \a indexOf() inline int entries(const T & e, ssize_t start = 0) const { int ec = 0; if (start < 0) { start = piv_size + start; if (start < 0) start = 0; } for (size_t i = start; i < piv_size; ++i) { if (e == piv_data[i]) ++ec; } return ec; } //! \~english Count elements in the array passes the test implemented by the provided function `test`. //! \~russian Подсчитывает количество элементов в массиве, //! проходящих по условию, заданному в передаваемой функции `test`. //! \~\details //! \~english Overloaded function. //! Optional argument `start` - the position in this array at which to begin searching. //! If the index is greater than or equal to the array's size, //! 0 is returned, which means the array will not be searched. //! If the provided index value is a negative number, //! it is taken as the offset from the end of the array. //! Note: if the provided index is negative, //! the array is still searched from front to back. //! Default: 0 (entire array is searched). //! \~russian Перегруженная функция. //! Опциональный аргумент `start` указывает на индекс в массиве, откуда будет начинаться поиск. //! Если индекс больше или равен длине массива, //! возвращается 0, что означает, что массив даже не просматривается. //! Если индекс является отрицательным числом, он трактуется как смещение с конца массива. //! Если рассчитанный индекс все равно оказывается меньше 0, просматривается весь массив. //! Обратите внимание: если индекс отрицателен, массив всё равно просматривается от начала к концу (слева на право). //! Значение по умолчанию равно 0, что означает, что просматривается весь массив. //! \~\sa \a every(), \a any(), \a contains(), \a forEach(), \a indexWhere() inline int entries(std::function test, ssize_t start = 0) const { int ec = 0; if (start < 0) { start = piv_size + start; if (start < 0) start = 0; } for (size_t i = start; i < piv_size; ++i) { if (test(piv_data[i])) ++ec; } return ec; } //! \~english Returns the first index at which a given element `e` //! can be found in the array, or `-1` if it is not present. //! \~russian Возвращает первый индекс, по которому данный элемент `e` //! может быть найден в массиве или `-1`, если такого индекса нет. //! \~\details //! \~english Optional argument `start` - the position in this array at which to begin searching. //! If the index is greater than or equal to the array's size, //! `-1` is returned, which means the array will not be searched. //! If the provided index value is a negative number, //! it is taken as the offset from the end of the array. //! Note: if the provided index is negative, //! the array is still searched from front to back. //! Default: 0 (entire array is searched). //! \~russian Опциональный аргумент `start` указывает на индекс в массиве, откуда будет начинаться поиск. //! Если индекс больше или равен длине массива, //! возвращается `-1`, что означает, что массив даже не просматривается. //! Если индекс является отрицательным числом, он трактуется как смещение с конца массива. //! Если рассчитанный индекс все равно оказывается меньше 0, просматривается весь массив. //! Обратите внимание: если индекс отрицателен, массив всё равно просматривается от начала к концу (слева на право). //! Значение по умолчанию равно 0, что означает, что просматривается весь массив. //! \~\code //! PIVector v{2, 5, 9}; //! piCout << v.indexOf(2); // 0 //! piCout << v.indexOf(7); // -1 //! piCout << v.indexOf(9, 2); // 2 //! piCout << v.indexOf(2, -1); // -1 //! piCout << v.indexOf(2, -3); // 0 //! \endcode //! \~\sa \a indexWhere(), \a lastIndexOf(), \a lastIndexWhere(), \a contains() inline ssize_t indexOf(const T & e, ssize_t start = 0) const { if (start < 0) { start = piv_size + start; if (start < 0) start = 0; } for (size_t i = start; i < piv_size; ++i) { if (e == piv_data[i]) return i; } return -1; } //! \~english Returns the first index passes the test implemented by the provided function `test`, //! or `-1` if it is not present. //! can be found in the array, or `-1` if it is not present. //! \~russian Возвращает первый индекс элемента проходящего по условию, //! заданному в передаваемой функции `test`, или `-1`, если таких элементов нет. //! \~\details //! \~english Optional argument `start` - the position in this array at which to begin searching. //! If the index is greater than or equal to the array's size, //! `-1` is returned, which means the array will not be searched. //! If the provided index value is a negative number, //! it is taken as the offset from the end of the array. //! Note: if the provided index is negative, //! the array is still searched from front to back. //! Default: 0 (entire array is searched). //! \~russian Опциональный аргумент `start` указывает на индекс в массиве, откуда будет начинаться поиск. //! Если индекс больше или равен длине массива, //! возвращается `-1`, что означает, что массив даже не просматривается. //! Если индекс является отрицательным числом, он трактуется как смещение с конца массива. //! Если рассчитанный индекс все равно оказывается меньше 0, просматривается весь массив. //! Обратите внимание: если индекс отрицателен, массив всё равно просматривается от начала к концу (слева на право). //! Значение по умолчанию равно 0, что означает, что просматривается весь массив. //! \~\code //! PIVector v{"do", "re", "mi", "re"}; //! piCout << v.indexWhere([](const PIString & s){return s.startsWith('r');}); // 1 //! piCout << v.indexWhere([](const PIString & s){return s.startsWith('r');}, 2); // 3 //! piCout << v.indexWhere([](const PIString & s){return s.startsWith('k');}); // -1 //! \endcode //! \~\sa \a indexOf(), \a lastIndexOf(), \a lastIndexWhere(), \a contains() inline ssize_t indexWhere(std::function test, ssize_t start = 0) const { if (start < 0) { start = piv_size + start; if (start < 0) start = 0; } for (size_t i = start; i < piv_size; ++i) { if (test(piv_data[i])) return i; } return -1; } //! \~english Returns the last index at which a given element `e` //! can be found in the array, or `-1` if it is not present. //! \~russian Возвращает последний индекс, по которому данный элемент `e` //! может быть найден в массиве или `-1`, если такого индекса нет. //! \~\details //! \~english Optional argument `start` - the position in this array //! at which to start searching backwards. //! If the index is greater than or equal to the array's size, //! causes the whole array to be searched. //! If the provided index value is a negative number, //! it is taken as the offset from the end of the array. //! Therefore, if calculated index less than 0, //! the array is not searched, and the method returns `-1`. //! Note: if the provided index is negative, //! the array is still searched from back to front. //! Default: -1 (entire array is searched). //! \~russian Опциональный аргумент `start` указывает на индекс //! c которого начинать поиск в обратном направлении. //! Если индекс больше или равен длине массива, просматривается весь массив. //! Если индекс является отрицательным числом, он трактуется как смещение с конца массива. //! Обратите внимание: если индекс отрицателен, массив всё равно просматривается от конца к началу (справа на лево). //! Если рассчитанный индекс оказывается меньше 0, массив даже не просматривается. //! Значение по умолчанию равно `-1`, что равно индексу последнего элемента //! и означает, что просматривается весь массив. //! \~\code //! PIVector v{2, 5, 9, 2}; //! piCout << v.lastIndexOf(2); // 3 //! piCout << v.lastIndexOf(7); // -1 //! piCout << v.lastIndexOf(2, 2); // 0 //! piCout << v.lastIndexOf(2, -3); // 0 //! piCout << v.lastIndexOf(2, -300); // -1 //! piCout << v.lastIndexOf(2, 300); // 3 //! \endcode //! \~\sa \a indexOf(), \a indexWhere(), \a lastIndexWhere(), \a contains() inline ssize_t lastIndexOf(const T & e, ssize_t start = -1) const { if (start >= size_s()) start = piv_size - 1; if (start < 0) start = piv_size + start; for (ssize_t i = start; i >= 0; --i) { if (e == piv_data[i]) return i; } return -1; } //! \~english Returns the last index passes the test implemented by the provided function `test`, //! or `-1` if it is not present. //! \~russian Возвращает последний индекс элемента проходящего по условию, //! заданному в передаваемой функции `test`, или `-1`, если таких элементов нет. //! \~\details //! \~english Optional argument `start` - the position in this array //! at which to start searching backwards. //! If the index is greater than or equal to the array's size, //! causes the whole array to be searched. //! If the provided index value is a negative number, //! it is taken as the offset from the end of the array. //! Therefore, if calculated index less than 0, //! the array is not searched, and the method returns `-1`. //! Note: if the provided index is negative, //! the array is still searched from back to front. //! Default: -1 (entire array is searched). //! \~russian Опциональный аргумент `start` указывает на индекс //! c которого начинать поиск в обратном направлении. //! Если индекс больше или равен длине массива, просматривается весь массив. //! Если индекс является отрицательным числом, он трактуется как смещение с конца массива. //! Обратите внимание: если индекс отрицателен, массив всё равно просматривается от конца к началу (справа на лево). //! Если рассчитанный индекс оказывается меньше 0, массив даже не просматривается. //! Значение по умолчанию равно `-1`, что равно индексу последнего элемента //! и означает, что просматривается весь массив. //! \~\sa \a indexOf(), \a lastIndexOf(), \a indexWhere(), \a contains() inline ssize_t lastIndexWhere(std::function test, ssize_t start = -1) const { if (start >= size_s()) start = piv_size - 1; if (start < 0) start = piv_size + start; for (ssize_t i = start; i >= 0; --i) { if (test(piv_data[i])) return i; } return -1; } //! \~english Pointer to array //! \~russian Указатель на память массива //! \~\details //! \~english Optional argument `index` the position in this array, //! where is pointer. Default: start of array. //! \~russian Опциональный аргумент `index` указывает на индекс c которого брать указатель. //! По умолчанию указывает на начало массива. //! \~\code //! PIVector v{2, 5, 9, 2}; //! int a[2] = {12, 13}; //! memcpy(vec.data(1), a, 2 * sizeof(int)); //! piCout << v; // {2, 12, 13, 2} //! \endcode inline T * data(size_t index = 0) { return &(piv_data[index]); } //! \~english Read only pointer to array //! \~russian Указатель на память массива только для чтения. //! \~\details //! \~english The pointer can be used to access and modify the items in the array. //! The pointer remains valid as long as the array isn't reallocated. //! Optional argument `index` the position in this array, //! where is pointer. Default: start of array. //! \~russian Указатель можно использовать для доступа и изменения элементов в массиве. //! Указатель остается действительным только до тех пор, пока массив не будет перераспределен. //! Опциональный аргумент `index` указывает на индекс c которого брать указатель. //! По умолчанию указывает на начало массива. //! \~\code //! PIVector v{1, 3, 5}; //! int a[3]; //! memcpy(a, v.data(), a.size() * sizeof(int)); //! piCout << a[0] << a[1] << a[2]; // 1 3 5 //! \endcode inline const T * data(size_t index = 0) const { return &(piv_data[index]); } //! \~english Creates sub-array of this array. //! \~russian Создает подмассив, то есть кусок из текущего массива. //! \~english //! \param index - index of this array where sub-array starts //! \param count - sub-array size //! \~russian //! \param index - индекс в текущем массиве, откуда начинётся подмассив //! \param count - размер подмассива //! \~\details //! \~english //! Index must be in range from `0` to `size()-1`. //! If sub-array size more than this array size, than ends early. //! \~russian //! Индекс начала должен лежать в диапазоне от `0` до `size()-1`. //! Если заданный размер подмассива превышает размер текущего массива, //! то вернется подмассив меньшего размера (`size()-index-1`). PIVector getRange(size_t index, size_t count) const { if (index >= piv_size || count == 0) return PIVector(); if (index + count > piv_size) count = piv_size - index; return PIVector(piv_data + index, count); } //! \~english Clear array, remove all elements. //! \~russian Очищает массив, удаляет все элементы. //! \~\details //! \~\note //! \~english Reserved memory will not be released. //! \~russian Зарезервированная память не освободится. //! \~\sa \a resize() template::value, int>::type = 0> inline PIVector & clear() { deleteT(piv_data, piv_size); piv_size = 0; return *this; } template::value, int>::type = 0> inline PIVector & clear() { PIINTROSPECTION_CONTAINER_UNUSED(T, piv_size) piv_size = 0; return *this; } //! \~english Assigns element 'e' to all items in the array. //! \~russian Заполняет весь массив копиями элемента 'e'. //! \~\details //! \code //! PIVector v{1, 3, 5}; //! v.fill(7); //! piCout << v; // {7, 7, 7} //! \endcode //! \~\sa \a resize() inline PIVector & fill(const T & e = T()) { deleteT(piv_data, piv_size); PIINTROSPECTION_CONTAINER_USED(T, piv_size) for (size_t i = 0; i < piv_size; ++i) { elementNew(piv_data + i, e); } return *this; } //! \~english Assigns result of function 'f(size_t i)' to all items in the array. //! \~russian Заполняет весь массив результатом вызова функции 'f(size_t i)'. //! \~\details //! \code //! PIVector v{1, 3, 5}; //! v.fill([](size_t i){return i*2;}); //! piCout << v; // {0, 2, 4} //! \endcode //! \~\sa \a resize() inline PIVector & fill(std::function f) { deleteT(piv_data, piv_size); PIINTROSPECTION_CONTAINER_USED(T, piv_size) for (size_t i = 0; i < piv_size; ++i) { elementNew(piv_data + i, f(i)); } return *this; } //! \~english Same as \a fill(). //! \~russian Тоже самое что и \a fill(). //! \~\sa \a fill(), \a resize() inline PIVector & assign(const T & e = T()) { return fill(e); } //! \~english First does `resize(new_size)` then `fill(e)`. //! \~russian Сначала делает `resize(new_size)`, затем `fill(e)`. //! \~\sa \a fill(), \a resize() template::value, int>::type = 0> inline PIVector & assign(size_t new_size, const T & f) { resize(new_size); return fill(f); } template::value, int>::type = 0> inline PIVector & assign(size_t new_size, const T & f) { _resizeRaw(new_size); return fill(f); } //! \~english Sets size of the array, new elements are copied from `e`. //! \~russian Устанавливает размер массива, новые элементы копируются из `e`. //! \~\details //! \~english If `new_size` is greater than the current \a size(), //! elements are added to the end; the new elements are initialized from `e`. //! If `new_size` is less than the current \a size(), elements are removed from the end. //! \~russian Если `new_size` больше чем текущий размер массива \a size(), //! новые элементы добавляются в конец массива и создаются из `e`. //! Если `new_size` меньше чем текущий размер массива \a size(), //! лишние элементы удаляются с конца массива. //! \~\sa \a size(), \a clear() inline PIVector & resize(size_t new_size, const T & e = T()) { if (new_size < piv_size) { deleteT(piv_data + new_size, piv_size - new_size); piv_size = new_size; } else if (new_size > piv_size) { expand(new_size, e); } return *this; } //! \~english Sets size of the array, new elements created by function `f(size_t i)`. //! \~russian Устанавливает размер массива, новые элементы создаются функцией `f(size_t i)`. //! \~\details //! \~english If `new_size` is greater than the current \a size(), //! elements are added to the end; the new elements created by function `f(size_t i)`. //! If `new_size` is less than the current \a size(), elements are removed from the end. //! \~russian Если `new_size` больше чем текущий размер массива \a size(), //! новые элементы добавляются в конец массива и функцией `f(size_t i)`. //! Если `new_size` меньше чем текущий размер массива \a size(), //! лишние элементы удаляются с конца массива. //! \~\sa \a size(), \a clear() inline PIVector & resize(size_t new_size, std::function f) { if (new_size < piv_size) { deleteT(piv_data + new_size, piv_size - new_size); piv_size = new_size; } else if (new_size > piv_size) { expand(new_size, f); } return *this; } template::value, int>::type = 0> inline PIVector & _resizeRaw(size_t new_size) { #if defined(PIP_INTROSPECTION) && !defined(PIP_FORCE_NO_PIINTROSPECTION) if (new_size > piv_size) { PIINTROSPECTION_CONTAINER_USED(T, (new_size - piv_size)); } if (new_size < piv_size) { PIINTROSPECTION_CONTAINER_UNUSED(T, (piv_size - new_size)); } #endif alloc(new_size); return *this; } inline void _copyRaw(T * dst, const T * src, size_t size) { newT(dst, src, size); } //! \~english Attempts to allocate memory for at least `new_size` elements. //! \~russian Резервируется память под как минимум `new_size` элементов. //! \~\details //! \~english If you know in advance how large the array will be, //! you should call this function to prevent reallocations and memory fragmentation. //! If `new_size` is greater than the current \a capacity(), //! new storage is allocated, otherwise the function does nothing. //! This function does not change the \a size() of the array. //! \~russian Если вы заранее знаете, насколько велик будет массив, //! вы можете вызвать эту функцию, чтобы предотвратить перераспределение и фрагментацию памяти. //! Если размер `new_size` больше чем выделенная память \a capacity(), //! то произойдёт выделение новой памяти и перераспределение массива. //! Эта функция не изменяет количество элементов в массиве \a size(). //! \~\sa \a size(), \a capacity(), \a resize() inline PIVector & reserve(size_t new_size) { if (new_size <= piv_rsize) return *this; const size_t os = piv_size; alloc(new_size); piv_size = os; return *this; } //! \~english Inserts value `e` at `index` position in the array. //! \~russian Вставляет значение `e` в позицию `index` в массиве. //! \~\details //! \~english The index must be greater than 0 and less than or equal to \a size(). //! \~russian Индекс должен быть больше 0 и меньше или равен \a size(). //! \code //! PIVector v{1, 3, 5}; //! v.insert(2, 7); //! piCout << v; // {1, 3, 7, 5} //! \endcode //! \~\sa \a append(), \a prepend(), \a remove() inline PIVector & insert(size_t index, const T & e = T()) { alloc(piv_size + 1); if (index < piv_size - 1) { const size_t os = piv_size - index - 1; memmove(reinterpret_cast(piv_data + index + 1), reinterpret_cast(piv_data + index), os * sizeof(T)); } PIINTROSPECTION_CONTAINER_USED(T, 1) elementNew(piv_data + index, e); return *this; } //! \~english Inserts value `e` at `index` position in the array. //! \~russian Вставляет значение `e` в позицию `index` в массиве. //! \~\details //! \~english The index must be greater than 0 and less than or equal to \a size(). //! \~russian Индекс должен быть больше 0 и меньше или равен \a size(). //! \~\sa \a append(), \a prepend(), \a remove() inline PIVector & insert(size_t index, T && e) { alloc(piv_size + 1); if (index < piv_size - 1) { const size_t os = piv_size - index - 1; memmove(reinterpret_cast(piv_data + index + 1), reinterpret_cast(piv_data + index), os * sizeof(T)); } PIINTROSPECTION_CONTAINER_USED(T, 1) elementNew(piv_data + index, std::move(e)); return *this; } //! \~english Inserts array `v` at `index` position in the array. //! \~russian Вставляет массив `v` в позицию `index` в массиве. //! \~\details //! \~english The index must be greater than or equal to 0 and less than or equal to \a size(). //! \~russian Индекс должен быть больше или равен 0 и меньше или равен \a size(). //! \~\sa \a append(), \a prepend(), \a remove() inline PIVector & insert(size_t index, const PIVector & v) { if (v.isEmpty()) return *this; #ifndef NDEBUG if (&v == this) { fprintf(stderr, "error with PIVector<%s>::insert\n", __PIP_TYPENAME__(T)); } #endif assert(&v != this); const ssize_t os = piv_size - index; alloc(piv_size + v.piv_size); if (os > 0) { memmove(reinterpret_cast(piv_data + index + v.piv_size), reinterpret_cast(piv_data + index), os * sizeof(T)); } newT(piv_data + index, v.piv_data, v.piv_size); return *this; } //! \~english Inserts the given elements at `index` position in the array. //! \~russian Вставляет элементы в позицию `index` в массиве. //! \~\details //! \~english The index must be greater than or equal to 0 and less than or equal to \a size(). //! Inserts the given elements from //! [C++11 initializer list](https://en.cppreference.com/w/cpp/utility/initializer_list). //! \~russian Индекс должен быть больше или равен 0 и меньше или равен \a size(). //! Вставляет элементы из //! [списка инициализации C++11](https://ru.cppreference.com/w/cpp/utility/initializer_list). //! \~\sa \a append(), \a prepend(), \a remove() inline PIVector & insert(size_t index, std::initializer_list init_list) { if (init_list.size() == 0) return *this; const ssize_t os = piv_size - index; alloc(piv_size + init_list.size()); if (os > 0) { memmove(reinterpret_cast(piv_data + index + init_list.size()), reinterpret_cast(piv_data + index), os * sizeof(T)); } newT(piv_data + index, init_list.begin(), init_list.size()); return *this; } //! \~english Removes `count` elements from the middle of the array, starting at `index` position. //! \~russian Удаляет элементы из массива, начиная с позиции `index` в количестве `count`. //! \~\details //! \code //! PIVector v{1, 3, 7, 5}; //! v.remove(1, 2); //! piCout << v; // {1, 5} //! \endcode //! \~\sa \a resize(), \a insert(), \a removeOne(), \a removeAll(), \a removeWhere() inline PIVector & remove(size_t index, size_t count = 1) { if (count == 0) return *this; if (index + count >= piv_size) { if (index < piv_size) { deleteT(piv_data + index, piv_size - index); piv_size = index; } } else { const size_t os = piv_size - index - count; deleteT(piv_data + index, count); memmove(reinterpret_cast(piv_data + index), reinterpret_cast(piv_data + index + count), os * sizeof(T)); piv_size -= count; } return *this; } //! \~english Swaps array `v` other with this array. //! \~russian Меняет местами массив `v` с этим массивом. //! \~\details //! \~english This operation is very fast and never fails. //! \~russian Эта операция выполняется мгновенно без копирования памяти и никогда не дает сбоев. inline void swap(PIVector & v) { piSwap(piv_data, v.piv_data); piSwap(piv_size, v.piv_size); piSwap(piv_rsize, v.piv_rsize); } //! \~english Sorts the elements in non-descending order. //! \~russian Сортировка элементов в порядке возрастания. //! \~\details //! \~english The order of equal elements is not guaranteed to be preserved. //! Elements are compared using operator<. //! Sorting provided by [std::sort](https://en.cppreference.com/w/cpp/algorithm/sort). //! Complexity `O(N·log(N))`. //! \~russian Сохранность порядка элементов, имеющих одинаковое значение, не гарантируется. //! Для сравнения элементов используется оператор `operator<`. //! Для сортировки используется функция [std::sort](https://ru.cppreference.com/w/cpp/algorithm/sort). //! Сложность сортировки `O(N·log(N))`. //! \~\code //! PIVector v{5, 7, 4, 2, 8, 6, 1, 9, 0, 3}; //! v.sort(); //! piCout << v; // {0, 1, 2, 3, 4, 5, 6, 7, 8, 9} //! \endcode //! \~\sa \a sort(std::function comp) inline PIVector & sort() { std::sort(begin(), end()); return *this; } //! \~english Sorts the elements in non-descending order. //! \~russian Сортировка элементов в порядке возрастания. //! \~\details //! \~english The order of equal elements is not guaranteed to be preserved. //! Elements are compared using the given binary comparison function `comp`. //! which returns `​true` if the first argument is less than (i.e. is ordered before) the second. //! The signature of the comparison function should be equivalent to the following: //! \code //! bool comp(const T &a, const T &b); //! \endcode //! While the signature does not need to have const &, the function must not modify the objects passed to it. //! The function must return `false` for identical elements, //! otherwise, it will lead to undefined program behavior and memory errors. //! Sorting provided by [std::sort](https://en.cppreference.com/w/cpp/algorithm/sort). //! Complexity `O(N·log(N))`. //! \~russian Сохранность порядка элементов, имеющих одинаковое значение, не гарантируется. //! Для сравнения элементов используется функция сравнения `comp`. //! Функция сравнения, возвращает ​`true` если первый аргумент меньше //! второго. Сигнатура функции сравнения должна быть эквивалентна следующей: \code bool comp(const T &a, const T &b); \endcode Сигнатура //! не обязана содержать const &, однако, функция не может изменять переданные объекты. Функция обязана возвращать `false` для //! одинаковых элементов, иначе это приведёт к неопределённому поведению программы и ошибкам памяти. Для сортировки используется функция //! [std::sort](https://ru.cppreference.com/w/cpp/algorithm/sort). Сложность сортировки `O(N·log(N))`. //! \~\code //! PIVector v{5, 7, 4, 2, 8, 6, 1, 9, 0, 3}; //! v.sort([](const int & a, const int & b){return a > b;}); //! piCout << v; // {9, 8, 7, 6, 5, 4, 3, 2, 1, 0} //! \endcode //! \~\sa \a sort() inline PIVector & sort(std::function comp) { std::sort(begin(), end(), comp); return *this; } //! \~english Reverses this array. //! \~russian Обращает порядок следования элементов этого массива. //! \~\details //! \~english This method reverses an array [in place](https://en.wikipedia.org/wiki/In-place_algorithm). //! The first array element becomes the last, and the last array element becomes the first. //! The reverse method transposes the elements of the calling array object in place, //! mutating the array, and returning a reference to the array. //! \~russian Метод reverse() на месте переставляет элементы массива, //! на котором он был вызван, изменяет массив и возвращает ссылку на него. //! Первый элемент массива становится последним, а последний — первым. //! \~\code //! PIVector v{1, 3, 7, 5}; //! v.reverse(); //! piCout << v; // {5, 7, 3, 1} //! \endcode //! \~\sa \a reversed() inline PIVector & reverse() { const size_t s2 = piv_size / 2; for (size_t i = 0; i < s2; ++i) { piSwap(piv_data[i], piv_data[piv_size - i - 1]); } return *this; } //! \~english Returns reversed array. //! \~russian Возвращает перевернутый массив. //! \~\details //! \~english Returns a copy of the array with elements in reverse order. //! The first array element becomes the last, and the last array element becomes the first. //! \~russian Возвращает копию массива с элементами в обратном порядке. //! Первый элемент массива становится последним, а последний — первым. //! \~\sa \a reverse() inline PIVector reversed() const { PIVector ret(*this); return ret.reverse(); } //! \~english Increases or decreases the size of the array by `add_size` elements. //! \~russian Увеличивает или уменьшает размер массива на `add_size` элементов. //! \~\details //! \~english If `add_size > 0` then elements are added to the end of the array. //! If `add_size < 0` then elements are removed from the end of the array. //! If `add_size < 0` and there are fewer elements in the array than specified, then the array becomes empty. //! \~russian Если `add_size > 0`, то в конец массива добавляются элементы. //! Если `add_size < 0`, то с конца массива удаляются элементы. //! Если `add_size < 0` и в массиве меньше элементов чем указано, то массив становится пустым. //! \~\sa \a resize() inline PIVector & enlarge(ssize_t add_size, const T & e = T()) { const ssize_t ns = size_s() + add_size; if (ns <= 0) clear(); else resize(size_t(ns), e); return *this; } //! \~english Remove no more than one element equal `e`. //! \~russian Удаляет первый элемент, который равен элементу `e`. //! \~\details //! \~\code //! PIVector v{3, 2, 5, 2, 7}; //! v.removeOne(2); //! piCout << v; // {3, 5, 2, 7} //! \endcode //! \~\sa \a remove(), \a removeAll(), \a removeWhere() inline PIVector & removeOne(const T & e) { for (size_t i = 0; i < piv_size; ++i) { if (piv_data[i] == e) { remove(i); return *this; } } return *this; } //! \~english Remove all elements equal `e`. //! \~russian Удаляет все элементы, равные элементу `e`. //! \~\details //! \~\code //! PIVector v{3, 2, 5, 2, 7}; //! v.removeAll(2); //! piCout << v; // {3, 5, 7} //! \endcode //! \~\sa \a remove(), \a removeOne(), \a removeWhere() inline PIVector & removeAll(const T & e) { ssize_t j = indexOf(e); if (j != -1) { for (size_t i = j + 1; i < piv_size; ++i) { if (piv_data[i] != e) { piv_data[j++] = std::move(piv_data[i]); } } remove(j, piv_size - j); } return *this; } //! \~english Remove all elements in the array //! passes the test implemented by the provided function `test`. //! \~russian Удаляет все элементы, удовлетворяющие условию, //! заданному в передаваемой функции `test`. //! \~\details //! \~\code //! PIVector v{3, 2, 5, 2, 7}; //! v.removeWhere([](const int & i){return i > 2;}); //! piCout << v; // {2, 2} //! \endcode //! \~\sa \a remove(), \a removeOne(), \a removeWhere() inline PIVector & removeWhere(std::function test) { ssize_t j = indexWhere(test); if (j != -1) { for (size_t i = j + 1; i < piv_size; ++i) { if (!test(piv_data[i])) { piv_data[j++] = std::move(piv_data[i]); } } remove(j, piv_size - j); } return *this; } //! \~english Appends the given element `e` to the end of the array. //! \~russian Добавляет элемент `e` в конец массива. //! \~\details //! \~english If size() is less than capacity(), which is most often //! then the addition will be very fast. //! In any case, the addition is fast and does not depend on the size of the array. //! If the new size() is greater than capacity() //! then all iterators and references //! (including the past-the-end iterator) are invalidated. //! Otherwise only the past-the-end iterator is invalidated. //! \~russian Если size() меньше capacity(), что часто бывает, //! то добавление будет очень быстрым. //! В любом случае добавление быстрое и не зависит от размера массива. //! Если новый size() больше, чем capacity(), //! то все итераторы и указатели становятся нерабочими. //! В противном случае все, кроме итераторов, указывающих на конец массива, //! остаются в рабочем состоянии. //! \~\code //! PIVector v{1, 2, 3}; //! v.push_back(4); //! v.push_back(5); //! piCout << v; // {1, 2, 3, 4, 5} //! \endcode //! \~\sa \a push_front(), \a append(), \a prepend(), \a insert() inline PIVector & push_back(const T & e) { alloc(piv_size + 1); PIINTROSPECTION_CONTAINER_USED(T, 1); elementNew(piv_data + piv_size - 1, e); return *this; } //! \~english Appends the given element `e` to the end of the array. //! \~russian Добавляет элемент `e` в конец массива. //! \~\details //! \~english Overloaded function. //! \~russian Перегруженая функция. //! \~\sa \a push_back() inline PIVector & push_back(T && e) { alloc(piv_size + 1); PIINTROSPECTION_CONTAINER_USED(T, 1); elementNew(piv_data + piv_size - 1, std::move(e)); return *this; } //! \~english Appends the given elements to the end of the array. //! \~russian Добавляет элементы в конец массива. //! \~\details //! \~english Overloaded function. //! Appends the given elements from //! [C++11 initializer list](https://en.cppreference.com/w/cpp/utility/initializer_list). //! \~russian Перегруженая функция. //! Добавляет элементы из //! [списка инициализации C++11](https://ru.cppreference.com/w/cpp/utility/initializer_list). //! \~\sa \a push_back() inline PIVector & push_back(std::initializer_list init_list) { if (init_list.size() == 0) return *this; const size_t ps = piv_size; alloc(piv_size + init_list.size()); newT(piv_data + ps, init_list.begin(), init_list.size()); return *this; } //! \~english Appends the given array `v` to the end of the array. //! \~russian Добавляет массив `v` в конец массива. //! \~\details //! \~english Overloaded function. //! \~russian Перегруженая функция. //! \~\sa \a push_back() inline PIVector & push_back(const PIVector & v) { if (v.isEmpty()) return *this; #ifndef NDEBUG if (&v == this) { fprintf(stderr, "error with PIVector<%s>::push_back\n", __PIP_TYPENAME__(T)); } #endif assert(&v != this); const size_t ps = piv_size; alloc(piv_size + v.piv_size); newT(piv_data + ps, v.piv_data, v.piv_size); return *this; } //! \~english Appends the given element `e` to the end of the array. //! \~russian Добавляет элемент `e` в конец массива. //! \~\details //! \~\details //! \~english If size() is less than capacity(), which is most often //! then the addition will be very fast. //! In any case, the addition is fast and does not depend on the size of the array. //! If the new size() is greater than capacity() //! then all iterators and references //! (including the past-the-end iterator) are invalidated. //! Otherwise only the past-the-end iterator is invalidated. //! \~russian Если size() меньше capacity(), что часто бывает, //! то добавление будет очень быстрым. //! В любом случае добавление быстрое и не зависит от размера массива. //! Если новый size() больше, чем capacity(), //! то все итераторы и указатели становятся нерабочими. //! В противном случае все, кроме итераторов, указывающих на конец массива, //! остаются в рабочем состоянии. //! \~\code //! PIVector v{1, 2, 3}; //! v.append(4); //! v.append(5); //! piCout << v; // {1, 2, 3, 4, 5} //! \endcode //! \~\sa \a prepend(), \a push_front(), \a push_back(), \a insert() inline PIVector & append(const T & e) { return push_back(e); } //! \~english Appends the given element `e` to the end of the array. //! \~russian Добавляет элемент `e` в конец массива. //! \~\details //! \~english Overloaded function. //! \~russian Перегруженая функция. //! \~\sa \a append() inline PIVector & append(T && e) { return push_back(std::move(e)); } //! \~english Appends the given elements to the end of the array. //! \~russian Добавляет элементы в конец массива. //! \~\details //! \~english Overloaded function. //! Appends the given elements from //! [C++11 initializer list](https://en.cppreference.com/w/cpp/utility/initializer_list). //! \~russian Перегруженая функция. //! Добавляет элементы из //! [списка инициализации C++11](https://ru.cppreference.com/w/cpp/utility/initializer_list). //! \~\sa \a append() inline PIVector & append(std::initializer_list init_list) { return push_back(init_list); } //! \~english Appends the given array `v` to the end of the array. //! \~russian Добавляет массив `v` в конец массива. //! \~\details //! \~english Overloaded function. //! \~russian Перегруженая функция. //! \~\code //! PIVector v{1, 2, 3}; //! v.append(PIVector{4, 5}); //! piCout << v; // {1, 2, 3, 4, 5} //! \endcode //! \~\sa \a append() inline PIVector & append(const PIVector & v) { return push_back(v); } //! \~english Appends the given element `e` to the end of the array. //! \~russian Добавляет элемент `e` в конец массива. //! \~\details //! \~\code //! PIVector v{1, 2, 3}; //! v << 4 << 5; //! piCout << v; // {1, 2, 3, 4, 5} //! \endcode //! \~\sa \a append() inline PIVector & operator<<(const T & e) { return push_back(e); } //! \~english Appends the given element `e` to the end of the array. //! \~russian Добавляет элемент `e` в конец массива. //! \~\details //! \~\code //! PIVector v{1, 2, 3}; //! v << 4 << 5; //! piCout << v; // {1, 2, 3, 4, 5} //! \endcode //! \~\sa \a append() inline PIVector & operator<<(T && e) { return push_back(std::move(e)); } //! \~english Appends the given array `v` to the end of the array. //! \~russian Добавляет массив `v` в конец массива. //! \~\details //! \~\code //! PIVector v{1, 2, 3}; //! v << PIVector{4, 5}; //! piCout << v; // {1, 2, 3, 4, 5} //! \endcode //! \~\sa \a append() inline PIVector & operator<<(const PIVector & v) { return push_back(v); } //! \~english Appends the given element `e` to the begin of the array. //! \~russian Добавляет элемент `e` в начало массива. //! \~\details //! \~english Adding an element to the beginning takes longer than to the end. //! This time is directly proportional to the size of the array. //! All iterators and references are invalidated. //! \~russian Добавление элемента в начало выполняется дольше, чем в конец. //! Это время прямопропорционально размеру массива. //! При добавлении элемента все итераторы и указатели становятся нерабочими. //! \~\code //! PIVector v{1, 2, 3}; //! v.push_front(4); //! v.push_front(5); //! piCout << v; // {5, 4, 1, 2, 3} //! \endcode //! \~\sa \a push_back(), \a append(), \a prepend(), \a insert() inline PIVector & push_front(const T & e) { return insert(0, e); } //! \~english Appends the given element `e` to the begin of the array. //! \~russian Добавляет элемент `e` в начало массива. //! \~\details //! \~english Overloaded function. //! \~russian Перегруженая функция. //! \~\sa \a push_front() inline PIVector & push_front(T && e) { return insert(0, std::move(e)); } //! \~english Appends the given array `v` to the begin of the array. //! \~russian Добавляет массив `v` в начало массива. //! \~\details //! \~english Overloaded function. //! \~russian Перегруженая функция. //! \~\code //! PIVector v{1, 2, 3}; //! v.push_front(PIVector{4, 5}); //! piCout << v; // {4, 5, 1, 2, 3} //! \endcode //! \~\sa \a push_front() inline PIVector & push_front(const PIVector & v) { return insert(0, v); } //! \~english Appends the given elements to the begin of the array. //! \~russian Добавляет элементы в начало массива. //! \~\details //! \~english Overloaded function. //! Appends the given elements from //! [C++11 initializer list](https://en.cppreference.com/w/cpp/utility/initializer_list). //! \~russian Перегруженая функция. //! Добавляет элементы из //! [списка инициализации C++11](https://ru.cppreference.com/w/cpp/utility/initializer_list). //! \~\sa \a append() inline PIVector & push_front(std::initializer_list init_list) { return insert(0, init_list); } //! \~english Appends the given element `e` to the begin of the array. //! \~russian Добавляет элемент `e` в начало массива. //! \~\details //! \~english Adding an element to the beginning takes longer than to the end. //! This time is directly proportional to the size of the array. //! All iterators and references are invalidated. //! \~russian Добавление элемента в начало выполняется дольше, чем в конец. //! Это время прямопропорционально размеру массива. //! При добавлении элемента все итераторы и указатели становятся нерабочими. //! \~\code //! PIVector v{1, 2, 3}; //! v.prepend(4); //! v.prepend(5); //! piCout << v; // {5, 4, 1, 2, 3} //! \endcode //! \~\sa \a append(), \a push_back(), \a push_front(), \a insert() inline PIVector & prepend(const T & e) { return push_front(e); } //! \~english Appends the given element `e` to the begin of the array. //! \~russian Добавляет элемент `e` в начало массива. //! \~\details //! \~english Overloaded function. //! \~russian Перегруженая функция. //! \~\sa \a prepend() inline PIVector & prepend(T && e) { return push_front(std::move(e)); } //! \~english Appends the given array `v` to the begin of the array. //! \~russian Добавляет массив `v` в начало массива. //! \~\details //! \~english Overloaded function. //! \~russian Перегруженая функция. //! \~\code //! PIVector v{1, 2, 3}; //! v.prepend(PIVector{4, 5}); //! piCout << v; // {4, 5, 1, 2, 3} //! \endcode //! \~\sa \a prepend() inline PIVector & prepend(const PIVector & v) { return push_front(v); } //! \~english Appends the given elements to the begin of the array. //! \~russian Добавляет элементы в начало массива. //! \~\details //! \~english Overloaded function. //! Appends the given elements from //! [C++11 initializer list](https://en.cppreference.com/w/cpp/utility/initializer_list). //! \~russian Перегруженая функция. //! Добавляет элементы из //! [списка инициализации C++11](https://ru.cppreference.com/w/cpp/utility/initializer_list). //! \~\sa \a append() inline PIVector & prepend(std::initializer_list init_list) { return prepend(init_list); } //! \~english Remove one element from the end of the array. //! \~russian Удаляет один элемент с конца массива. //! \~\details //! \~english Deleting an element from the end is very fast //! and does not depend on the size of the array. //! \~russian Удаление элемента с конца выполняется очень быстро //! и не зависит от размера массива. //! \~\code //! PIVector v{1, 2, 3}; //! v.pop_back(); //! piCout << v; // {1, 2} //! \endcode //! \~\sa \a pop_front(), \a take_back(), \a take_front() inline PIVector & pop_back() { if (piv_size == 0) return *this; deleteT(piv_data + piv_size - 1, 1); piv_size = piv_size - 1; return *this; } //! \~english Remove one element from the begining of the array. //! \~russian Удаляет один элемент с начала массива. //! \~\details //! \~english Removing an element from the beginning takes longer than from the end. //! This time is directly proportional to the size of the array. //! All iterators and references are invalidated. //! \~russian Удаление элемента с начала выполняется дольше, чем с конца. //! Это время прямопропорционально размеру массива. //! При удалении элемента все итераторы и указатели становятся нерабочими. //! \~\code //! PIVector v{1, 2, 3}; //! v.pop_front(); //! piCout << v; // {2, 3} //! \endcode //! \~\sa \a pop_back(), \a take_back(), \a take_front() inline PIVector & pop_front() { if (piv_size == 0) return *this; remove(0); return *this; } //! \~english Remove one element from the end of the array and return it. //! \~russian Удаляет один элемент с начала массива и возвращает его. //! \~\details //! \~\code //! PIVector v{1, 2, 3}; //! piCout << v.take_back(); // 3 //! piCout << v; // {1, 2} //! \endcode //! \~\sa \a take_front(), \a pop_back(), \a pop_front() inline T take_back() { const T e(back()); pop_back(); return e; } //! \~english Remove one element from the begining of the array and return it. //! \~russian Удаляет один элемент с конца массива и возвращает его. //! \~\details //! \~\code //! PIVector v{1, 2, 3}; //! piCout << v.take_front(); // 1 //! piCout << v; // {2, 3} //! \endcode //! \~\sa \a take_front(), \a pop_back(), \a pop_front() inline T take_front() { const T e(front()); pop_front(); return e; } //! \~english Returns an array converted to another type. //! \~russian Возвращает конвертированный в другой тип массив. //! \~\details //! \~\code //! PIVector v{1.1, 2.5, 3.8}; //! PIVector v2 = v.toType(); //! piCout << v2; // {1, 2, 3} //! \endcode //! \~\sa \a map() template inline PIVector toType() const { PIVector ret; ret.reserve(piv_size); for (size_t i = 0; i < piv_size; ++i) { ret << ST(piv_data[i]); } return ret; } //! \~english Returns a new array with all elements //! that pass the test implemented by the provided function `bool test(const T & e)`. //! \~russian Возвращает новый массив со всеми элементами, //! прошедшими проверку, задаваемую в передаваемой функции `bool test(const T & e)`. //! \~\details //! \~\code //! PIVector v{3, 2, 5, 2, 7}; //! PIVector v2 = v.filter([](const int & i){return i > 2;}); //! piCout << v2; // {3, 5, 7} //! \endcode //! \~\sa \a map(), \a any(), \a every() inline PIVector filter(std::function test) const { PIVector ret; for (size_t i = 0; i < piv_size; ++i) { if (test(piv_data[i])) ret << piv_data[i]; } return ret; } //! \~english Same as \a filter() but with `index` parameter in `test`. //! \~russian Аналогично \a filter() но с параметром индекса `index` в функции `test`. //! \~\sa \a filter() inline PIVector filterIndexed(std::function test) const { PIVector ret; for (size_t i = 0; i < piv_size; ++i) { if (test(i, piv_data[i])) ret << piv_data[i]; } return ret; } //! \~english Same as \a filter() but from end to begin (from right to left). //! \~russian Аналогично \a filter() но от конца до начала (справа на лево). //! \~\sa \a filter() inline PIVector filterReverse(std::function test) const { PIVector ret; for (ssize_t i = piv_size; i >= 0; --i) { if (test(piv_data[i])) ret << piv_data[i]; } return ret; } //! \~english Same as \a filterReverse() but with `index` parameter in `test`. //! \~russian Аналогично \a filterReverse() но с параметром индекса `index` в функции `test`. //! \~\sa \a filterReverse() inline PIVector filterReverseIndexed(std::function test) const { PIVector ret; for (ssize_t i = piv_size; i >= 0; --i) { if (test(i, piv_data[i])) ret << piv_data[i]; } return ret; } //! \~english Execute function `void f(const T & e)` for every element in array. //! \~russian Выполняет функцию `void f(const T & e)` для каждого элемента массива. //! \~\details //! \~russian Не позволяет изменять элементы массива. //! Для редактирования элементов используйте функцию вида `void f(T & e)`. //! \~english Does not allow changing array elements. //! To edit elements, use the function like `void f(T & e)` //! \~\code //! PIVector v{1, 2, 3, 4, 5}; //! int s = 0; //! v.forEach([&s](const int & e){s += e;}); //! piCout << s; // 15 //! \endcode //! \~\sa \a filter(), \a map(), \a reduce(), \a any(), \a every() inline void forEach(std::function f) const { for (size_t i = 0; i < piv_size; ++i) { f(piv_data[i]); } } //! \~english Execute function `void f(T & e)` for every element in array. //! \~russian Выполняет функцию `void f(T & e)` для каждого элемента массива. //! \~\details //! \~english Overloaded function. //! Allows you to change the elements of the array. //! \~russian Перегруженая функция. //! Позволяет изменять элементы массива. //! \~\code //! PIVector v{1, 2, 3, 4, 5}; //! v.forEach([](int & e){e++;}); //! piCout << v; // {2, 3, 4, 5, 6} //! \endcode //! \~\sa \a filter(), \a map(), \a reduce(), \a any(), \a every() inline PIVector & forEach(std::function f) { for (size_t i = 0; i < piv_size; ++i) { f(piv_data[i]); } return *this; } //! \~english Same as \a forEach() but with `index` parameter in `f`. //! \~russian Аналогично \a forEach() но с параметром индекса `index` в функции `f`. //! \~\sa \a forEach() inline void forEachIndexed(std::function f) const { for (size_t i = 0; i < piv_size; ++i) { f(i, piv_data[i]); } } //! \~english Same as \a forEachIndexed(), but allows you to change the elements of the array. //! \~russian Аналогично \a forEachIndexed(), но позволяет изменять элементы массива. //! \~\sa \a forEach(), \a forEachIndexed() inline PIVector & forEachIndexed(std::function f) { for (size_t i = 0; i < piv_size; ++i) { f(i, piv_data[i]); } return *this; } //! \~english Same as \a forEach() but from end to begin (from right to left). //! \~russian Аналогично \a forEach() но от конца до начала (справа на лево). //! \~\sa \a forEach() inline void forEachReverse(std::function f) const { for (ssize_t i = piv_size; i >= 0; --i) { f(piv_data[i]); } } //! \~english Same as \a forEachReverse(), but allows you to change the elements of the array. //! \~russian Аналогично \a forEachReverse(), но позволяет изменять элементы массива. //! \~\sa \a forEach(), \a forEachReverse() inline PIVector & forEachReverse(std::function f) { for (ssize_t i = piv_size; i >= 0; --i) { f(piv_data[i]); } return *this; } //! \~english Same as \a forEachIndexed() but from end to begin (from right to left). //! \~russian Аналогично \a forEachIndexed() но от конца до начала (справа на лево). //! \~\sa \a forEachIndexed(), \a forEachReverse(), \a forEach() inline void forEachReverseIndexed(std::function f) const { for (ssize_t i = piv_size; i >= 0; --i) { f(i, piv_data[i]); } } //! \~english Same as \a forEachReverseIndexed(), but allows you to change the elements of the array. //! \~russian Аналогично \a forEachReverseIndexed(), но позволяет изменять элементы массива. //! \~\sa \a forEachReverseIndexed(), \a forEachIndexed(), \a forEachReverse(), \a forEach() inline PIVector & forEachReverseIndexed(std::function f) { for (ssize_t i = piv_size; i >= 0; --i) { f(i, piv_data[i]); } return *this; } //! \~english Сreates a new array populated with the results //! of calling a provided function `ST f(const T & e)` on every element in the calling array. //! \~russian Создаёт новый массив с результатом вызова указанной функции //! `ST f(const T & e)` для каждого элемента массива. //! \~\details //! \~english Calls a provided function`ST f(const T & e)` //! once for each element in an array, in order, //! and constructs a new array from the results. //! \~russian Метод `map` вызывает переданную функцию `ST f(const T & e)` //! один раз для каждого элемента в порядке их появления //! и конструирует новый массив из результатов её вызова. //! \~\code //! PIVector v{1, 2, 3}; //! PIVector sl = v.map([](const int & i){return PIString::fromNumber(i);}); //! piCout << sl; // {"1", "2", "3"} //! \endcode //! \~\sa \a forEach(), \a reduce() template inline PIVector map(std::function f) const { PIVector ret; ret.reserve(piv_size); for (size_t i = 0; i < piv_size; ++i) { ret << f(piv_data[i]); } return ret; } //! \~english Same as \a map() but with `index` parameter in `f`. //! \~russian Аналогично \a map() но с параметром индекса `index` в функции `f`. //! \~\code //! PIVector v{1, 2, 3}; //! PIVector sl = v.mapIndexed([](size_t index, const int & i){return PIString::fromNumber(index);}); //! piCout << sl; // {"0", "1", "2"} //! \endcode //! \~\sa \a map() template inline PIVector mapIndexed(std::function f) const { PIVector ret; ret.reserve(piv_size); for (size_t i = 0; i < piv_size; ++i) { ret << f(i, piv_data[i]); } return ret; } //! \~english Same as \a map() but from end to begin (from right to left). //! \~russian Аналогично \a map() но от конца до начала (справа на лево). //! \~\code //! PIVector v{1, 2, 3}; //! PIVector sl = v.mapReverse([](const int & i){return PIString::fromNumber(i);}); //! piCout << sl; // {"3", "2", "1"} //! \endcode //! \~\sa \a map() template inline PIVector mapReverse(std::function f) const { PIVector ret; ret.reserve(piv_size); for (ssize_t i = piv_size; i >= 0; --i) { ret << f(piv_data[i]); } return ret; } //! \~english Same as \a mapReverse() but with `index` parameter in `f`. //! \~russian Аналогично \a mapReverse() но с параметром индекса `index` в функции `f`. //! \~\code //! PIVector v{1, 2, 3}; //! PIVector sl = v.mapReverseIndexed([](size_t index, const int & i){return PIString::fromNumber(index);}); //! piCout << sl; // {"2", "1", "0"} //! \endcode //! \~\sa \a mapReverse() template inline PIVector mapReverseIndexed(std::function f) const { PIVector ret; ret.reserve(piv_size); for (ssize_t i = piv_size; i >= 0; --i) { ret << f(i, piv_data[i]); } return ret; } //! \~english Applies the function `ST f(const T & e, const ST & acc)` //! to each element of the array (from left to right), returns one value. //! \~russian Применяет функцию `ST f(const T & e, const ST & acc)` //! к каждому элементу массива (слева-направо), возвращает одно значение. //! \~\details //! \~english The reduce() method performs the `f` function //! once for each element in the array. //! If the `initial` argument is passed when calling reduce(), //! then when the function `f` is called for the first time, //! the value of `acc` will be assigned to `initial`. //! If the array is empty, the value `initial` will be returned. //! \param f is a function like `ST f(const T & e, const ST & acc)`, //! executed for each element of the array. It takes two arguments: //! * **e** - current element of the array //! * **acc** - accumulator accumulating the value //! which this function returns after visiting the next element //! //! \param initial _optional_ Object used as the second argument //! when the `f` function is first called. //! \~russian Метод reduce() выполняет функцию `f` //! один раз для каждого элемента, присутствующего в массиве. //! Если при вызове reduce() передан аргумент `initial`, //! то при первом вызове функции `f` значение `acc` //! будет равным значению `initial`. //! Если массив пустой то будет возвращено значение `initial`. //! \param f Функция, вида `ST f(const T & e, const ST & acc)`, //! выполняющаяся для каждого элемента массива. //! Она принимает два аргумента: //! * **e** - текущий элемент массива //! * **acc** - аккумулятор, аккумулирующий значение //! которое возвращает эта функция после посещения очередного элемента //! //! \param initial _опциональный_ Объект, //! используемый в качестве второго аргумента при первом вызове функции `f`. //! //! \~\code //! PIVector v{1, 2, 3, 4, 5}; //! int s = v.reduce([](const int & e, const int & acc){return e + acc;}); //! piCout << s; // 15 //! \endcode //! \~\sa \a forEach(), \a map() template inline ST reduce(std::function f, const ST & initial = ST()) const { ST ret(initial); for (size_t i = 0; i < piv_size; ++i) { ret = f(piv_data[i], ret); } return ret; } //! \~english Same as \a reduce() but with `index` parameter in `f`. //! \~russian Аналогично \a reduce() но с параметром индекса `index` в функции `f`. //! \~\sa \a reduce() template inline ST reduceIndexed(std::function f, const ST & initial = ST()) const { ST ret(initial); for (size_t i = 0; i < piv_size; ++i) { ret = f(i, piv_data[i], ret); } return ret; } //! \~english Same as \a reduce() but from end to begin (from right to left). //! \~russian Аналогично \a reduce() но от конца до начала (справа на лево). //! \~\sa \a reduce() template inline ST reduceReverse(std::function f, const ST & initial = ST()) const { ST ret(initial); for (ssize_t i = piv_size; i >= 0; --i) { ret = f(piv_data[i], ret); } return ret; } //! \~english Same as \a reduceReverse() but with `index` parameter in `f`. //! \~russian Аналогично \a reduceReverse() но с параметром индекса `index` в функции `f`. //! \~\sa \a reduceReverse() template inline ST reduceReverseIndexed(std::function f, const ST & initial = ST()) const { ST ret(initial); for (ssize_t i = piv_size; i >= 0; --i) { ret = f(i, piv_data[i], ret); } return ret; } //! \~english Changes the dimension of the array, creates a two-dimensional array from a one-dimensional array. //! \~russian Изменяет размерность массива, из одномерного массива создает двухмерный. //! \~\details //! \~russian //! \param rows размер внешнего массива //! \param cols размер внутренних массивов //! \param order порядок обхода исходного массива, задаётся с помощью \a ReshapeOrder //! \~english //! \param rows size external array //! \param cols size internal arrays //! \param order the order of traversing the source array is set using \a ReshapeOrder //! \~\code //! PIVector v{1, 2, 3, 4}; //! PIVector> m1 = v.reshape(2,2); //! piCout << m1; // {{1, 2}, {3, 4}} //! PIVector> m2 = v.reshape(2,2, ReshapeByColumn); //! piCout << m2; // {{1, 3}, {2, 4}} //! \endcode //! \~\sa \a map(), \a reduce(), \a flatten() inline PIVector> reshape(size_t rows, size_t cols, ReshapeOrder order = ReshapeByRow) const { #ifndef NDEBUG if (rows * cols != piv_size) { fprintf(stderr, "error with PIVector<%s>::reshape\n", __PIP_TYPENAME__(T)); } #endif assert(rows * cols == piv_size); PIVector> ret; if (isEmpty()) return ret; ret.expand(rows); if (order == ReshapeByRow) { for (size_t r = 0; r < rows; r++) { ret[r] = PIVector(&(piv_data[r * cols]), cols); } } if (order == ReshapeByColumn) { for (size_t r = 0; r < rows; r++) { ret[r].resize(cols); for (size_t c = 0; c < cols; c++) { ret[r][c] = piv_data[c * rows + r]; } } } return ret; } //! \~english Changes the dimension of the array, creates a one-dimensional array from a two-dimensional array. //! \~russian Изменяет размерность массива, из двухмерный массива создает одномерный. //! \~\details //! \~russian Делает массив плоским. //! Порядок обхода исходного массива задаётся с помощью \a ReshapeOrder. //! \~english Makes the array flat. //! Еhe order of traversing the source array is set using \a ReshapeOrder. //! \~\code //! PIVector v{1, 2, 3, 4, 5, 6}; //! PIVector> xv = v.reshape(3,2); //! piCout << xv; // {{1, 2}, {3, 4}, {5, 6}} //! piCout << xv.flatten(); // {1, 2, 3, 4, 5, 6} //! \endcode //! \~\sa \a map(), \a reduce(), \a reshape() template>::value, int>::type = 0> inline PIVector flatten(ReshapeOrder order = ReshapeByRow) const { PIVector ret; if (isEmpty()) return ret; const size_t rows = size(); const size_t cols = at(0).size(); ret.reserve(rows * cols); if (order == ReshapeByRow) { for (size_t r = 0; r < rows; r++) { ret.append(at(r)); } } if (order == ReshapeByColumn) { for (size_t c = 0; c < cols; c++) { for (size_t r = 0; r < rows; r++) { ret << at(r)[c]; } } } ret.resize(rows * cols); return ret; } //! \~english Changes the dimension of the two-dimensional array. //! \~russian Изменяет размерность двухмерного массива. //! \~\details //! \~russian //! \param rows размер внешнего массива //! \param cols размер внутренних массивов //! \param order порядок обхода исходного массива, задаётся с помощью \a ReshapeOrder //! \~english //! \param rows size external array //! \param cols size internal arrays //! \param order the order of traversing the source array is set using \a ReshapeOrder //! \~\code //! PIVector v{1, 2, 3, 4, 5, 6}; //! PIVector> xv = v.reshape(3,2); //! piCout << xv; // {{1, 2}, {3, 4}, {5, 6}} //! piCout << xv.reshape(2,3); // {{1, 2, 3}, {4, 5, 6}} //! \endcode //! \~\sa \a map(), \a reduce(), \a reshape() template>::value, int>::type = 0> inline PIVector> reshape(size_t rows, size_t cols, ReshapeOrder order = ReshapeByRow) const { PIVector fl = flatten(); return fl.reshape(rows, cols, order); } //! \~english Divides an array into a two-dimensional array using the separator `separator`. //! \~russian Разделяет массив на двумерный массив с помощью разделителя`separator`. //! \~\code //! PIVector v{1, 2, 3, 99, 4, 5, 99, 6}; //! piCout << v.split(99); // {{1, 2, 3}, {4, 5}, {6}} //! \endcode //! \~\sa \a splitBySize() inline PIVector> split(const T & separator) const { PIVector> ret; if (isEmpty()) return ret; size_t start = 0; ssize_t ci = indexOf(separator, start); while (ci >= 0) { ret << PIVector(piv_data + start, ci - start); start = ci + 1; ci = indexOf(separator, start); } if (start < piv_size) { ret << PIVector(piv_data + start, piv_size - start); } return ret; } //! \~english Divides an array into a two-dimensional array in chunks of no more than `sz`. //! \~russian Разделяет массив на двумерный массив по кускам не более чем `sz`. //! \~\sa \a split() inline PIVector> splitBySize(size_t sz) const { PIVector> ret; if (isEmpty() || sz == 0) return ret; const size_t ch = piv_size / sz; for (size_t i = 0; i < ch; ++i) { ret << PIVector(piv_data + sz * i, sz); } const size_t t = ch * sz; if (t < piv_size) { ret << PIVector(piv_data + t, piv_size - t); } return ret; } //! \~english Cut sub-array of this array. //! \~russian Вырезает подмассив, то есть кусок из текущего массива. //! \~english //! \param index - index of this array where sub-array starts //! \param count - sub-array size //! \~russian //! \param index - индекс в текущем массиве, откуда начинётся подмассив //! \param count - размер подмассива //! \~\details //! \~english //! Index must be in range from `0` to `size()-1`. //! If sub-array size more than this array size, than ends early. //! \~russian //! Индекс начала должен лежать в диапазоне от `0` до `size()-1`. //! Если заданный размер подмассива превышает размер текущего массива, //! то вернется подмассив меньшего размера (`size()-index-1`). inline PIVector takeRange(size_t index, size_t count) { PIVector ret; if (index >= piv_size || count == 0) return ret; if (index + count > piv_size) count = piv_size - index; ret.alloc(count); memcpy(reinterpret_cast(ret.piv_data), reinterpret_cast(piv_data + index), count * sizeof(T)); const size_t os = piv_size - index - count; if (os > 0) { memmove(reinterpret_cast(piv_data + index), reinterpret_cast(piv_data + index + count), os * sizeof(T)); piv_size -= count; } else { piv_size = index; } return ret; } private: inline void _reset() { piv_size = 0; piv_rsize = 0; piv_data = nullptr; } template::value, int>::type = 0> inline void newT(T * dst, const T * src, size_t s) { PIINTROSPECTION_CONTAINER_USED(T, s) for (size_t i = 0; i < s; ++i) { elementNew(dst + i, src[i]); } } template::value, int>::type = 0> inline void newT(T * dst, const T * src, size_t s) { PIINTROSPECTION_CONTAINER_USED(T, s) memcpy(reinterpret_cast(dst), reinterpret_cast(src), s * sizeof(T)); } template::value, int>::type = 0> inline void deleteT(T * d, size_t sz) { PIINTROSPECTION_CONTAINER_UNUSED(T, sz) if (d != nullptr) { for (size_t i = 0; i < sz; ++i) { elementDelete(d[i]); } } } template::value, int>::type = 0> inline void deleteT(T * d, size_t sz) { PIINTROSPECTION_CONTAINER_UNUSED(T, sz) } template::value, int>::type = 0> inline void elementNew(T * to, const T & from) { new (to) T(from); } template::value, int>::type = 0> inline void elementNew(T * to, T && from) { new (to) T(std::move(from)); } template::value, int>::type = 0> inline void elementNew(T1 * to, const T & from) { (*to) = from; } template::value, int>::type = 0> inline void elementNew(T * to, T && from) { (*to) = std::move(from); } template::value, int>::type = 0> inline void elementDelete(T & from) { from.~T(); } template::value, int>::type = 0> inline void elementDelete(T & from) {} inline void dealloc() { if (piv_data != nullptr) { free(reinterpret_cast(piv_data)); piv_data = nullptr; } } inline void expand(size_t new_size, const T & e = T()) { const size_t os = piv_size; alloc(new_size); PIINTROSPECTION_CONTAINER_USED(T, (new_size - os)) for (size_t i = os; i < new_size; ++i) { elementNew(piv_data + i, e); } } inline void expand(size_t new_size, std::function f) { const size_t os = piv_size; alloc(new_size); PIINTROSPECTION_CONTAINER_USED(T, (new_size - os)) for (size_t i = os; i < new_size; ++i) { elementNew(piv_data + i, f(i)); } } inline void alloc(size_t new_size) { if (new_size <= piv_rsize) { piv_size = new_size; return; } piv_size = new_size; const size_t new_rsize = _PIContainerConstants::calcNewSize(piv_rsize, new_size); if (new_rsize == piv_rsize) return; PIINTROSPECTION_CONTAINER_ALLOC(T, (as - piv_rsize)) T * new_data = reinterpret_cast(realloc(reinterpret_cast(piv_data), new_rsize * sizeof(T))); #ifndef NDEBUG if (!new_data) { fprintf(stderr, "error with PIVector<%s>::alloc\n", __PIP_TYPENAME__(T)); } #endif assert(new_data); piv_data = new_data; piv_rsize = new_rsize; } T * piv_data = nullptr; size_t piv_size = 0; size_t piv_rsize = 0; }; #ifdef PIP_STD_IOSTREAM //! \~english Output operator to [std::ostream](https://en.cppreference.com/w/cpp/io/basic_ostream). //! \~russian Оператор вывода в [std::ostream](https://ru.cppreference.com/w/cpp/io/basic_ostream). template inline std::ostream & operator<<(std::ostream & s, const PIVector & v) { s << "{"; for (size_t i = 0; i < v.size(); ++i) { s << v[i]; if (i < v.size() - 1) s << ", "; } s << "}"; return s; } #endif //! \relatesalso PICout //! \~english Output operator to \a PICout //! \~russian Оператор вывода в \a PICout template inline PICout operator<<(PICout s, const PIVector & v) { s.space(); s.saveAndSetControls(0); s << "{"; for (size_t i = 0; i < v.size(); ++i) { s << v[i]; if (i < v.size() - 1) { s << ", "; } } s << "}"; s.restoreControls(); return s; } template inline void piSwap(PIVector & f, PIVector & s) { f.swap(s); } #endif // PIVECTOR_H