2335 lines
103 KiB
C++
2335 lines
103 KiB
C++
//! \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 <http://www.gnu.org/licenses/>.
|
||
*/
|
||
|
||
#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 𝓞(1)
|
||
//! - Insertion or removal of elements at the end - amortized constant 𝓞(1)
|
||
//! - Insertion or removal of elements - linear in the distance to the end of the array 𝓞(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 следующая:
|
||
//! - Произвольный доступ — постоянная 𝓞(1)
|
||
//! - Вставка и удаление элементов в конце — амортизированная постоянная 𝓞(1)
|
||
//! - Вставка и удаление элементов — линейная по расстоянию до конца массива 𝓞(n)
|
||
//!
|
||
//! \~\sa \a PIDeque, \a PIMap
|
||
template <typename T>
|
||
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(): piv_data(0), piv_size(0), piv_rsize(0) {
|
||
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): piv_data(0), piv_size(0), piv_rsize(0) {
|
||
PIINTROSPECTION_CONTAINER_NEW(T, sizeof(T))
|
||
alloc(size);
|
||
newT(piv_data, data, piv_size);
|
||
}
|
||
|
||
//! \~english Copy constructor.
|
||
//! \~russian Копирующий конструктор.
|
||
inline PIVector(const PIVector<T> & v): piv_data(0), piv_size(0), piv_rsize(0) {
|
||
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 <int> v{1,2,3};
|
||
//! piCout << v; // {1, 2, 3}
|
||
//! \endcode
|
||
inline PIVector(std::initializer_list<T> init_list): piv_data(0), piv_size(0), piv_rsize(0) {
|
||
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 PIVector(size_t size, const T & e = T()): piv_data(0), piv_size(0), piv_rsize(0) {
|
||
PIINTROSPECTION_CONTAINER_NEW(T, sizeof(T))
|
||
resize(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 <int> v(5, [](size_t i){return i*2;});
|
||
//! piCout << v; // {0, 2, 4, 6, 8}
|
||
//! \endcode
|
||
inline PIVector(size_t size, std::function<T(size_t i)> f): piv_data(0), piv_size(0), piv_rsize(0) {
|
||
PIINTROSPECTION_CONTAINER_NEW(T, sizeof(T))
|
||
resize(size, f);
|
||
}
|
||
|
||
//! \~english Move constructor.
|
||
//! \~russian Перемещающий конструктор.
|
||
inline PIVector(PIVector<T> && v): piv_data(v.piv_data), piv_size(v.piv_size), piv_rsize(v.piv_rsize) {
|
||
PIINTROSPECTION_CONTAINER_NEW(T, sizeof(T))
|
||
v._reset();
|
||
}
|
||
|
||
inline virtual ~PIVector() {
|
||
PIINTROSPECTION_CONTAINER_DELETE(T)
|
||
PIINTROSPECTION_CONTAINER_FREE(T, (piv_rsize))
|
||
deleteT(piv_data, piv_size);
|
||
dealloc();
|
||
_reset();
|
||
}
|
||
|
||
//! \~english Assign operator.
|
||
//! \~russian Оператор присваивания.
|
||
inline PIVector<T> & operator =(const PIVector<T> & v) {
|
||
if (this == &v) return *this;
|
||
clear();
|
||
deleteT(piv_data, piv_size);
|
||
alloc(v.piv_size);
|
||
newT(piv_data, v.piv_data, piv_size);
|
||
return *this;
|
||
}
|
||
|
||
//! \~english Assign move operator.
|
||
//! \~russian Оператор перемещающего присваивания.
|
||
inline PIVector<T> & operator =(PIVector<T> && v) {
|
||
swap(v);
|
||
return *this;
|
||
}
|
||
|
||
class iterator {
|
||
friend class PIVector<T>;
|
||
private:
|
||
inline iterator(PIVector<T> * v, ssize_t p): parent(v), pos(p) {}
|
||
PIVector<T> * 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) {
|
||
auto tmp = *this;
|
||
++*this;
|
||
return tmp;
|
||
}
|
||
inline iterator & operator --() {
|
||
--pos;
|
||
return *this;
|
||
}
|
||
inline iterator operator --(int) {
|
||
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<T>;
|
||
private:
|
||
inline const_iterator(const PIVector<T> * v, ssize_t p): parent(v), pos(p) {}
|
||
const PIVector<T> * 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) {
|
||
auto tmp = *this;
|
||
++*this;
|
||
return tmp;
|
||
}
|
||
inline const_iterator & operator --() {
|
||
--pos;
|
||
return *this;
|
||
}
|
||
inline const_iterator operator --(int) {
|
||
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<T>;
|
||
private:
|
||
inline reverse_iterator(PIVector<T> * v, ssize_t p): parent(v), pos(p) {}
|
||
PIVector<T> * 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) {
|
||
auto tmp = *this;
|
||
--*this;
|
||
return tmp;
|
||
}
|
||
inline reverse_iterator & operator --() {
|
||
++pos;
|
||
return *this;
|
||
}
|
||
inline reverse_iterator operator --(int) {
|
||
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<T>;
|
||
private:
|
||
inline const_reverse_iterator(const PIVector<T> * v, ssize_t p): parent(v), pos(p) {}
|
||
const PIVector<T> * 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) {
|
||
auto tmp = *this;
|
||
--*this;
|
||
return tmp;
|
||
}
|
||
inline const_reverse_iterator & operator --() {
|
||
++pos;
|
||
return *this;
|
||
}
|
||
inline const_reverse_iterator operator --(int) {
|
||
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 
|
||
//!
|
||
//! \~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 
|
||
//!
|
||
//! \~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 
|
||
//!
|
||
//! \~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 
|
||
//!
|
||
//! \~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<int> 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<bool(const T & e)> 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<int> 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<bool(const T & e)> 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<int> 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 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<T> & 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<T> & 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<int> 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 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<int> 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<bool(const T & e)> 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<int> 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<PIString> 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<bool(const T & e)> 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<int> 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<bool(const T & e)> 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<int> 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<int> 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<T> getRange(size_t index, size_t count) const {
|
||
if (index >= piv_size || count == 0) return PIVector<T>();
|
||
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<typename T1 = T, typename std::enable_if<
|
||
!std::is_trivially_copyable<T1>::value
|
||
, int>::type = 0>
|
||
inline PIVector<T> & clear() {
|
||
resize(0);
|
||
return *this;
|
||
}
|
||
template<typename T1 = T, typename std::enable_if<
|
||
std::is_trivially_copyable<T1>::value
|
||
, int>::type = 0>
|
||
inline PIVector<T> & 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<int> v{1, 3, 5};
|
||
//! v.fill(7);
|
||
//! piCout << v; // {7, 7, 7}
|
||
//! \endcode
|
||
//! \~\sa \a resize()
|
||
inline PIVector<T> & 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<int> v{1, 3, 5};
|
||
//! v.fill([](size_t i){return i*2;});
|
||
//! piCout << v; // {0, 2, 4}
|
||
//! \endcode
|
||
//! \~\sa \a resize()
|
||
inline PIVector<T> & fill(std::function<T(size_t i)> 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<T> & 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<typename T1 = T, typename std::enable_if<
|
||
!std::is_trivially_copyable<T1>::value
|
||
, int>::type = 0>
|
||
inline PIVector<T> & assign(size_t new_size, const T & f) {
|
||
resize(new_size);
|
||
return fill(f);
|
||
}
|
||
template<typename T1 = T, typename std::enable_if<
|
||
std::is_trivially_copyable<T1>::value
|
||
, int>::type = 0>
|
||
inline PIVector<T> & 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<T> & resize(size_t new_size, const T & e = T()) {
|
||
if (new_size < piv_size) {
|
||
T * de = &(piv_data[new_size]);
|
||
deleteT(de, piv_size - new_size);
|
||
piv_size = new_size;
|
||
}
|
||
if (new_size > piv_size) {
|
||
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);
|
||
}
|
||
}
|
||
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<T> & resize(size_t new_size, std::function<T(size_t i)> f) {
|
||
if (new_size < piv_size) {
|
||
T * de = &(piv_data[new_size]);
|
||
deleteT(de, piv_size - new_size);
|
||
piv_size = new_size;
|
||
}
|
||
if (new_size > piv_size) {
|
||
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));
|
||
}
|
||
}
|
||
return *this;
|
||
}
|
||
|
||
template<typename T1 = T, typename std::enable_if<
|
||
std::is_trivially_copyable<T1>::value
|
||
, int>::type = 0>
|
||
inline PIVector<T> & _resizeRaw(size_t new_size) {
|
||
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));
|
||
}
|
||
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<T> & reserve(size_t new_size) {
|
||
if (new_size <= piv_rsize) return *this;
|
||
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<int> v{1, 3, 5};
|
||
//! v.insert(2, 7);
|
||
//! piCout << v; // {1, 3, 7, 5}
|
||
//! \endcode
|
||
//! \~\sa \a append(), \a prepend(), \a remove()
|
||
inline PIVector<T> & insert(size_t index, const T & e = T()) {
|
||
alloc(piv_size + 1);
|
||
if (index < piv_size - 1) {
|
||
size_t os = piv_size - index - 1;
|
||
memmove((void*)(&(piv_data[index + 1])), (const void*)(&(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<T> & insert(size_t index, T && e) {
|
||
alloc(piv_size + 1);
|
||
if (index < piv_size - 1) {
|
||
size_t os = piv_size - index - 1;
|
||
memmove((void*)(&(piv_data[index + 1])), (const void*)(&(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<T> & insert(size_t index, const PIVector<T> & v) {
|
||
if (v.isEmpty()) return *this;
|
||
#ifndef NDEBUG
|
||
if (&v == this) {
|
||
printf("error with PIVector<%s>::insert\n", __PIP_TYPENAME__(T));
|
||
}
|
||
#endif
|
||
assert(&v != this);
|
||
ssize_t os = piv_size - index;
|
||
alloc(piv_size + v.piv_size);
|
||
if (os > 0) {
|
||
memmove((void*)(&(piv_data[index + v.piv_size])), (const void*)(&(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<T> & insert(size_t index, std::initializer_list<T> init_list) {
|
||
ssize_t os = piv_size - index;
|
||
alloc(piv_size + init_list.size());
|
||
if (os > 0) {
|
||
memmove((void*)(&(piv_data[index + init_list.size()])), (const void*)(&(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<int> 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<T> & remove(size_t index, size_t count = 1) {
|
||
if (count == 0) return *this;
|
||
if (index + count >= piv_size) {
|
||
resize(index);
|
||
return *this;
|
||
}
|
||
size_t os = piv_size - index - count;
|
||
deleteT(&(piv_data[index]), count);
|
||
memmove((void*)(&(piv_data[index])), (const void*)(&(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<T> & v) {
|
||
piSwap<T*>(piv_data, v.piv_data);
|
||
piSwap<size_t>(piv_size, v.piv_size);
|
||
piSwap<size_t>(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<int> 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<bool(const T &a, const T &b)> comp)
|
||
inline PIVector<T> & 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<int> 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<T> & sort(std::function<bool(const T &a, const T &b)> 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<int> v{1, 3, 7, 5};
|
||
//! v.reverse();
|
||
//! piCout << v; // {5, 7, 3, 1}
|
||
//! \endcode
|
||
//! \~\sa \a reversed()
|
||
inline PIVector<T> & reverse() {
|
||
size_t s2 = piv_size/2;
|
||
for (size_t i = 0; i < s2; ++i) {
|
||
piSwap<T>(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<T> reversed() const {
|
||
PIVector<T> 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<T> & enlarge(llong add_size, const T & e = T()) {
|
||
llong 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<int> 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<T> & 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<int> v{3, 2, 5, 2, 7};
|
||
//! v.removeAll(2);
|
||
//! piCout << v; // {3, 5, 7}
|
||
//! \endcode
|
||
//! \~\sa \a remove(), \a removeOne(), \a removeWhere()
|
||
inline PIVector<T> & removeAll(const T & e) {
|
||
for (ssize_t i = 0; i < size_s(); ++i) {
|
||
if (piv_data[i] == e) {
|
||
remove(i);
|
||
--i;
|
||
}
|
||
}
|
||
return *this;
|
||
}
|
||
|
||
//! \~english Remove all elements in the array
|
||
//! passes the test implemented by the provided function `test`.
|
||
//! \~russian Удаляет все элементы, удовлетворяющие условию,
|
||
//! заданному в передаваемой функции `test`.
|
||
//! \~\details
|
||
//! \~\code
|
||
//! PIVector<int> 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<T> & removeWhere(std::function<bool(const T & e)> test) {
|
||
for (ssize_t i = 0; i < size_s(); ++i) {
|
||
if (test(piv_data[i])) {
|
||
remove(i);
|
||
--i;
|
||
}
|
||
}
|
||
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<int> 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<T> & 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<T> & 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<T> & push_back(std::initializer_list<T> init_list) {
|
||
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<T> & push_back(const PIVector<T> & v) {
|
||
#ifndef NDEBUG
|
||
if (&v == this) {
|
||
printf("error with PIVector<%s>::push_back\n", __PIP_TYPENAME__(T));
|
||
}
|
||
#endif
|
||
assert(&v != this);
|
||
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<int> 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<T> & 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<T> & 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<T> & append(std::initializer_list<T> 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<int> v{1, 2, 3};
|
||
//! v.append(PIVector<int>{4, 5});
|
||
//! piCout << v; // {1, 2, 3, 4, 5}
|
||
//! \endcode
|
||
//! \~\sa \a append()
|
||
inline PIVector<T> & append(const PIVector<T> & v) {return push_back(v);}
|
||
|
||
//! \~english Appends the given element `e` to the end of the array.
|
||
//! \~russian Добавляет элемент `e` в конец массива.
|
||
//! \~\details
|
||
//! \~\code
|
||
//! PIVector<int> v{1, 2, 3};
|
||
//! v << 4 << 5;
|
||
//! piCout << v; // {1, 2, 3, 4, 5}
|
||
//! \endcode
|
||
//! \~\sa \a append()
|
||
inline PIVector<T> & 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<int> v{1, 2, 3};
|
||
//! v << 4 << 5;
|
||
//! piCout << v; // {1, 2, 3, 4, 5}
|
||
//! \endcode
|
||
//! \~\sa \a append()
|
||
inline PIVector<T> & 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<int> v{1, 2, 3};
|
||
//! v << PIVector<int>{4, 5};
|
||
//! piCout << v; // {1, 2, 3, 4, 5}
|
||
//! \endcode
|
||
//! \~\sa \a append()
|
||
inline PIVector<T> & operator <<(const PIVector<T> & 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<int> 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<T> & push_front(const T & e) {
|
||
insert(0, e);
|
||
return *this;
|
||
}
|
||
|
||
//! \~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<T> & push_front(T && e) {
|
||
insert(0, std::move(e));
|
||
return *this;
|
||
}
|
||
|
||
//! \~english Appends the given array `v` to the begin of the array.
|
||
//! \~russian Добавляет массив `v` в начало массива.
|
||
//! \~\details
|
||
//! \~english Overloaded function.
|
||
//! \~russian Перегруженая функция.
|
||
//! \~\code
|
||
//! PIVector<int> v{1, 2, 3};
|
||
//! v.push_front(PIVector<int>{4, 5});
|
||
//! piCout << v; // {4, 5, 1, 2, 3}
|
||
//! \endcode
|
||
//! \~\sa \a push_front()
|
||
inline PIVector<T> & push_front(const PIVector<T> & v) {
|
||
insert(0, v);
|
||
return *this;
|
||
}
|
||
|
||
//! \~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<T> & push_front(std::initializer_list<T> init_list) {
|
||
insert(0, init_list);
|
||
return *this;
|
||
}
|
||
|
||
//! \~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<int> 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<T> & 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<T> & 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<int> v{1, 2, 3};
|
||
//! v.prepend(PIVector<int>{4, 5});
|
||
//! piCout << v; // {4, 5, 1, 2, 3}
|
||
//! \endcode
|
||
//! \~\sa \a prepend()
|
||
inline PIVector<T> & prepend(const PIVector<T> & 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<T> & prepend(std::initializer_list<T> 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<int> v{1, 2, 3};
|
||
//! v.pop_back();
|
||
//! piCout << v; // {1, 2}
|
||
//! \endcode
|
||
//! \~\sa \a pop_front(), \a take_back(), \a take_front()
|
||
inline PIVector<T> & pop_back() {
|
||
if (piv_size == 0) return *this;
|
||
resize(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<int> v{1, 2, 3};
|
||
//! v.pop_front();
|
||
//! piCout << v; // {2, 3}
|
||
//! \endcode
|
||
//! \~\sa \a pop_back(), \a take_back(), \a take_front()
|
||
inline PIVector<T> & 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<int> 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() {
|
||
T e(back());
|
||
pop_back();
|
||
return e;
|
||
}
|
||
|
||
//! \~english Remove one element from the begining of the array and return it.
|
||
//! \~russian Удаляет один элемент с конца массива и возвращает его.
|
||
//! \~\details
|
||
//! \~\code
|
||
//! PIVector<int> 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() {
|
||
T e(front());
|
||
pop_front();
|
||
return e;
|
||
}
|
||
|
||
//! \~english Returns an array converted to another type.
|
||
//! \~russian Возвращает конвертированный в другой тип массив.
|
||
//! \~\details
|
||
//! \~\code
|
||
//! PIVector<double> v{1.1, 2.5, 3.8};
|
||
//! PIVector<int> v2 = v.toType<int>();
|
||
//! piCout << v2; // {1, 2, 3}
|
||
//! \endcode
|
||
//! \~\sa \a map()
|
||
template <typename ST>
|
||
inline PIVector<ST> toType() const {
|
||
PIVector<ST> 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 `test`.
|
||
//! \~russian Возвращает новый массив со всеми элементами,
|
||
//! прошедшими проверку, задаваемую в передаваемой функции `test`.
|
||
//! \~\details
|
||
//! \~\code
|
||
//! PIVector<int> v{3, 2, 5, 2, 7};
|
||
//! PIVector<int> v2 = v.filter([](const int & i){return i > 2;});
|
||
//! piCout << v2; // {3, 5, 7}
|
||
//! \endcode
|
||
//! \~\sa \a map(), \a any(), \a every()
|
||
inline PIVector<T> filter(std::function<bool(const T & e)> test) const {
|
||
PIVector<T> ret;
|
||
for (size_t i = 0; i < piv_size; ++i) {
|
||
if (test(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<int> 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<void(const T & e)> 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<int> 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<T> & forEach(std::function<void(T & e)> f) {
|
||
for (size_t i = 0; i < piv_size; ++i) {
|
||
f(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<int> v{1, 2, 3};
|
||
//! PIVector<PIString> sl = v.map<PIString>([](const int & i){return PIString::fromNumber(i);});
|
||
//! piCout << sl; {"1", "2", "3"}
|
||
//! \endcode
|
||
//! \~\sa \a forEach(), \a reduce()
|
||
template <typename ST>
|
||
inline PIVector<ST> map(std::function<ST(const T & e)> f) const {
|
||
PIVector<ST> ret; ret.reserve(piv_size);
|
||
for (size_t i = 0; i < piv_size; ++i) {
|
||
ret << f(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<int> v{1, 2, 3, 4, 5};
|
||
//! int s = v.reduce<int>([](const int & e, const int & acc){return e + acc;});
|
||
//! piCout << s; // 15
|
||
//! \endcode
|
||
//! \~\sa \a forEach(), \a map()
|
||
template <typename ST>
|
||
inline ST reduce(std::function<ST(const T & e, const ST & acc)> 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 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<int> v{1, 2, 3, 4};
|
||
//! PIVector<PIVector<int>> m1 = v.reshape(2,2);
|
||
//! piCout << m1; // {{1, 2}, {3, 4}}
|
||
//! PIVector<PIVector<int>> m2 = v.reshape(2,2, ReshapeByColumn);
|
||
//! piCout << m2; // {{1, 3}, {2, 4}}
|
||
//! \endcode
|
||
//! \~\sa \a map(), \a reduce(), \a flatten()
|
||
inline PIVector<PIVector<T>> reshape(size_t rows, size_t cols, ReshapeOrder order = ReshapeByRow) const {
|
||
#ifndef NDEBUG
|
||
if (rows*cols != piv_size) {
|
||
printf("error with PIVector<%s>::reshape\n", __PIP_TYPENAME__(T));
|
||
}
|
||
#endif
|
||
assert(rows*cols == piv_size);
|
||
PIVector<PIVector<T>> ret;
|
||
if (isEmpty()) return ret;
|
||
ret.resize(rows);
|
||
if (order == ReshapeByRow) {
|
||
for (size_t r = 0; r < rows; r++) {
|
||
ret[r] = PIVector<T>(&(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<int> v{1, 2, 3, 4, 5, 6};
|
||
//! PIVector<PIVector<int>> xv = v.reshape(3,2);
|
||
//! piCout << xv; // {{1, 2}, {3, 4}, {5, 6}}
|
||
//! piCout << xv.flatten<int>(); // {1, 2, 3, 4, 5, 6}
|
||
//! \endcode
|
||
//! \~\sa \a map(), \a reduce(), \a reshape()
|
||
template<typename C, typename std::enable_if<
|
||
std::is_same<T, PIVector<C>>::value
|
||
, int>::type = 0>
|
||
inline PIVector<C> flatten(ReshapeOrder order = ReshapeByRow) const {
|
||
PIVector<C> ret;
|
||
if (isEmpty()) return ret;
|
||
size_t rows = size();
|
||
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<int> v{1, 2, 3, 4, 5, 6};
|
||
//! PIVector<PIVector<int>> xv = v.reshape(3,2);
|
||
//! piCout << xv; // {{1, 2}, {3, 4}, {5, 6}}
|
||
//! piCout << xv.reshape<int>(2,3); // {{1, 2, 3}, {4, 5, 6}}
|
||
//! \endcode
|
||
//! \~\sa \a map(), \a reduce(), \a reshape()
|
||
template<typename C, typename std::enable_if<
|
||
std::is_same<T, PIVector<C>>::value
|
||
, int>::type = 0>
|
||
inline PIVector<PIVector<C>> reshape(size_t rows, size_t cols, ReshapeOrder order = ReshapeByRow) const {
|
||
PIVector<C> fl = flatten<C>();
|
||
return fl.reshape(rows, cols, order);
|
||
}
|
||
|
||
private:
|
||
inline void _reset() {piv_size = piv_rsize = 0; piv_data = 0;}
|
||
inline size_t asize(size_t s) {
|
||
if (s == 0) return 0;
|
||
if (piv_rsize + piv_rsize >= s && piv_rsize < s) {
|
||
return piv_rsize + piv_rsize;
|
||
}
|
||
ssize_t t = 0, s_ = s - 1;
|
||
while (s_ >> t) ++t;
|
||
return (1 << t);
|
||
}
|
||
template<typename T1 = T, typename std::enable_if<
|
||
!std::is_trivially_copyable<T1>::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<typename T1 = T, typename std::enable_if<
|
||
std::is_trivially_copyable<T1>::value
|
||
, int>::type = 0>
|
||
inline void newT(T * dst, const T * src, size_t s) {
|
||
PIINTROSPECTION_CONTAINER_USED(T, s)
|
||
memcpy((void*)(dst), (const void*)(src), s * sizeof(T));
|
||
}
|
||
template<typename T1 = T, typename std::enable_if<
|
||
!std::is_trivially_copyable<T1>::value
|
||
, int>::type = 0>
|
||
inline void deleteT(T * d, size_t sz) {
|
||
PIINTROSPECTION_CONTAINER_UNUSED(T, sz)
|
||
if ((uchar*)d != 0) {
|
||
for (size_t i = 0; i < sz; ++i) {
|
||
elementDelete(d[i]);
|
||
}
|
||
}
|
||
}
|
||
template<typename T1 = T, typename std::enable_if<
|
||
std::is_trivially_copyable<T1>::value
|
||
, int>::type = 0>
|
||
inline void deleteT(T * d, size_t sz) {
|
||
PIINTROSPECTION_CONTAINER_UNUSED(T, sz)
|
||
}
|
||
template<typename T1 = T, typename std::enable_if<
|
||
!std::is_trivially_copyable<T1>::value
|
||
, int>::type = 0>
|
||
inline void elementNew(T * to, const T & from) {new(to)T(from);}
|
||
template<typename T1 = T, typename std::enable_if<
|
||
!std::is_trivially_copyable<T1>::value
|
||
, int>::type = 0>
|
||
inline void elementNew(T * to, T && from) {new(to)T(std::move(from));}
|
||
template<typename T1 = T, typename std::enable_if<
|
||
std::is_trivially_copyable<T1>::value
|
||
, int>::type = 0>
|
||
inline void elementNew(T1 * to, const T & from) {(*to) = from;}
|
||
template<typename T1 = T, typename std::enable_if<
|
||
std::is_trivially_copyable<T1>::value
|
||
, int>::type = 0>
|
||
inline void elementNew(T * to, T && from) {(*to) = std::move(from);}
|
||
template<typename T1 = T, typename std::enable_if<
|
||
!std::is_trivially_copyable<T1>::value
|
||
, int>::type = 0>
|
||
inline void elementDelete(T & from) {from.~T();}
|
||
template<typename T1 = T, typename std::enable_if<
|
||
std::is_trivially_copyable<T1>::value
|
||
, int>::type = 0>
|
||
inline void elementDelete(T & from) {}
|
||
inline void dealloc() {
|
||
if ((uchar*)piv_data != 0) free((uchar*)piv_data);
|
||
piv_data = 0;
|
||
}
|
||
inline void alloc(size_t new_size) {
|
||
if (new_size <= piv_rsize) {
|
||
piv_size = new_size;
|
||
return;
|
||
}
|
||
piv_size = new_size;
|
||
size_t as = asize(new_size);
|
||
if (as == piv_rsize) return;
|
||
PIINTROSPECTION_CONTAINER_ALLOC(T, (as-piv_rsize))
|
||
T * p_d = (T*)(realloc((void*)(piv_data), as*sizeof(T)));
|
||
#ifndef NDEBUG
|
||
if (!p_d) {
|
||
printf("error with PIVector<%s>::alloc\n", __PIP_TYPENAME__(T));
|
||
}
|
||
#endif
|
||
assert(p_d);
|
||
piv_data = p_d;
|
||
piv_rsize = as;
|
||
}
|
||
|
||
T * piv_data;
|
||
size_t piv_size, piv_rsize;
|
||
};
|
||
|
||
|
||
#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<typename T>
|
||
inline std::ostream & operator <<(std::ostream & s, const PIVector<T> & 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<typename T>
|
||
inline PICout operator <<(PICout s, const PIVector<T> & v) {
|
||
s.space();
|
||
s.setControl(0, true);
|
||
s << "{";
|
||
for (size_t i = 0; i < v.size(); ++i) {
|
||
s << v[i];
|
||
if (i < v.size() - 1) {
|
||
s << ", ";
|
||
}
|
||
}
|
||
s << "}";
|
||
s.restoreControl();
|
||
return s;
|
||
}
|
||
|
||
template<typename T>
|
||
inline void piSwap(PIVector<T> & f, PIVector<T> & s) {f.swap(s);}
|
||
|
||
#endif // PIVECTOR_H
|