//! \~\addtogroup Types
//! \~\{
//! \~\file pibytearray.h
//! \~\brief
//! \~english Byte array
//! \~russian Байтовый массив
/*
    PIP - Platform Independent Primitives
    Byte array
    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 PIBYTEARRAY_H
#define PIBYTEARRAY_H

#include "pibinarystream.h"
#include "pichar.h"

#include <stdio.h>

class PIString;
class PIByteArray;


//! \~\ingroup Types
//! \~\brief
//! \~english The %PIByteArray class provides an array of bytes with efficient memory management and various manipulation operations.
//! \~russian Класс %PIByteArray предоставляет массив байтов с эффективным управлением памятью и различными операциями манипулирования.
class PIP_EXPORT PIByteArray: public PIBinaryStream<PIByteArray> {
public:
	typedef ::PIMemoryBlock RawData DEPRECATEDM("use PIMemoryBlock instead");

	//! \~english Constructs an empty byte array.
	//! \~russian Создает пустой байтовый массив.
	PIByteArray() {}

	//! \~english Constructs copy of byte array "o".
	//! \~russian Создает копию байтового массива "o".
	PIByteArray(const PIByteArray & o): d(o.d) {}

	//! \~english Constructs copy of byte array "o".
	//! \~russian Создает копию байтового массива "o".
	explicit PIByteArray(const PIDeque<uchar> & o): d(o) {}

	//! \~english Move constructor.
	//! \~russian Конструктор перемещения.
	PIByteArray(PIByteArray && o): d(std::move(o.d)) {}
	PIByteArray(PIDeque<uchar> && o): d(std::move(o)) {}

	//! \~english Constructs 0-filled byte array with size "size".
	//! \~russian Создает заполненный "0" байтовый массив размером "size".
	explicit PIByteArray(const uint size) { resize(size); }

	//! \~english Constructs byte array from data "data" and size "size".
	//! \~russian Создает байтовый массив из данных по указателю "data" размером "size".
	PIByteArray(const void * data, const uint size): d((const uchar *)data, size_t(size)) {}

	//! \~english Constructs byte array with size "size" filled by "t".
	//! \~russian Создает заполненный "t" байтовый массив размером "size".
	PIByteArray(const uint size, uchar t): d(size, t) {}

	//! \~english Constructs 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
	//! PIByteArray v{1,2,3};
	//! piCout << v; // {1, 2, 3}
	//! \endcode
	PIByteArray(std::initializer_list<uchar> init_list): d(init_list) {}

	//! \~english Swaps array `v` other with this array.
	//! \~russian Меняет местами массив `v` с этим массивом.
	//! \~\details
	//! \~english This operation is very fast and never fails.
	//! \~russian Эта операция выполняется мгновенно без копирования памяти и никогда не дает сбоев.
	inline void swap(PIByteArray & other) { d.swap(other.d); }

	//! \~english Iterator to the first element.
	//! \~russian Итератор на первый элемент.
	//! \~\details ![begin, end](doc/images/pivector_begin.png)
	//!
	//! \~english If the array is empty, the returned iterator is equal to \a end().
	//! \~russian Если массив - пуст, возвращаемый итератор будет равен \a end().
	//! \~\return \ref stl_iterators
	//! \~\sa \a end(), \a rbegin(), \a rend()
	inline PIDeque<uchar>::iterator begin() { return d.begin(); }

	//! \~english Iterator to the element following the last element.
	//! \~russian Итератор на элемент, следующий за последним элементом.
	//! \~\details ![begin, end](doc/images/pivector_begin.png)
	//!
	//! \~english This element acts as a placeholder;
	//! attempting to access it results in undefined behavior.
	//! \~russian Этот элемент существует лишь условно,
	//! попытка доступа к нему приведёт к выходу за разрешенную память.
	//! \~\return \ref stl_iterators
	//! \~\sa \a begin(), \a rbegin(), \a rend()
	inline PIDeque<uchar>::iterator end() { return d.end(); }

	inline PIDeque<uchar>::const_iterator begin() const { return d.begin(); }
	inline PIDeque<uchar>::const_iterator end() const { return d.end(); }

	//! \~english Returns a reverse iterator to the first element of the reversed array.
	//! \~russian Обратный итератор на первый элемент.
	//! \~\details ![rbegin, rend](doc/images/pivector_rbegin.png)
	//!
	//! \~english It corresponds to the last element of the non-reversed array.
	//! If the array is empty, the returned iterator is equal to \a rend().
	//! \~russian Итератор для прохода массива в обратном порядке.
	//! Указывает на последний элемент.
	//! Если массив пустой, то совпадает с итератором \a rend().
	//! \~\return \ref stl_iterators
	//! \~\sa \a rend(), \a begin(), \a end()
	inline PIDeque<uchar>::reverse_iterator rbegin() { return d.rbegin(); }

	//! \~english Returns a reverse iterator to the element.
	//! following the last element of the reversed array.
	//! \~russian Обратный итератор на элемент, следующий за последним элементом.
	//! \~\details ![rbegin, rend](doc/images/pivector_rbegin.png)
	//!
	//! \~english It corresponds to the element preceding the first element of the non-reversed array.
	//! This element acts as a placeholder, attempting to access it results in undefined behavior.
	//! \~russian Итератор для прохода массива в обратном порядке.
	//! Указывает на элемент, предшествующий первому элементу.
	//! Этот элемент существует лишь условно,
	//! попытка доступа к нему приведёт к выходу за разрешенную память.
	//! \~\return \ref stl_iterators
	//! \~\sa \a rbegin(), \a begin(), \a end()
	inline PIDeque<uchar>::reverse_iterator rend() { return d.rend(); }

	inline PIDeque<uchar>::const_reverse_iterator rbegin() const { return d.rbegin(); }
	inline PIDeque<uchar>::const_reverse_iterator rend() const { return d.rend(); }

	//! \~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 d.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 d.size_s(); }

	//! \~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 d.length(); }

	//! \~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 d.capacity(); }

	//! \~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 d.isEmpty(); }

	//! \~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 d.isNotEmpty(); }

	//! \~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
	//! \~\sa \a every(), \a contains(), \a entries(), \a forEach()
	inline bool any(std::function<bool(uchar e)> test) const { return d.any(std::move(test)); }

	//! \~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
	//! \~\sa \a any(), \a contains(), \a entries(), \a forEach()
	inline bool every(std::function<bool(uchar e)> test) const { return d.every(std::move(test)); }

	//! \~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`.
	//! Иначе это приведёт к неопределённому поведению программы и ошибкам памяти.
	//! \~\sa \a at()
	inline uchar & operator[](size_t index) { return d[index]; }
	inline uchar operator[](size_t index) const { return d[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 uchar at(size_t index) const { return d.at(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 uchar & back() { return d.back(); }
	inline uchar back() const { return d.back(); }

	//! \~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 uchar & front() { return d.front(); }
	inline uchar front() const { return d.front(); }

	//! \~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
	//! PIByteArray 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()
	inline bool contains(uchar e, ssize_t start = 0) const { return d.contains(e, start); }

	//! \~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, что означает, что просматривается весь массив.
	//! \~\sa \a every(), \a any(), \a contains(), \a indexOf()
	inline int entries(uchar e, ssize_t start = 0) const { return d.entries(e, start); }

	//! \~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 indexWhere()
	inline int entries(std::function<bool(uchar e)> test, ssize_t start = 0) const { return d.entries(std::move(test), start); }

	bool startsWith(const PIByteArray & o) const;

	bool endsWith(const PIByteArray & o) const;

	//! \~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
	//! PIByteArray 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 uchar & e, ssize_t start = 0) const { return d.indexOf(e, start); }

	//! \~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
	//! PIByteArray v{2, 5, 9};
	//! piCout << v.indexWhere([](const uchar & s){return s > 3;});    // 1
	//! piCout << v.indexWhere([](const uchar & s){return s > 3;}, 2); // 2
	//! piCout << v.indexWhere([](const uchar & s){return s > 10;});   // -1
	//! \endcode
	//! \~\sa \a indexOf(), \a lastIndexOf(), \a lastIndexWhere(), \a contains()
	inline ssize_t indexWhere(std::function<bool(const uchar & e)> test, ssize_t start = 0) const {
		return d.indexWhere(std::move(test), start);
	}

	//! \~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
	//! PIByteArray 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 uchar & e, ssize_t start = -1) const { return d.lastIndexOf(e, start); }

	//! \~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 uchar & e)> test, ssize_t start = -1) const {
		return d.lastIndexWhere(std::move(test), start);
	}

	//! \~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 которого брать указатель.
	//! По умолчанию указывает на начало массива.
	inline uchar * data(size_t index = 0) { return d.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 которого брать указатель.
	//! По умолчанию указывает на начало массива.
	inline const uchar * data(size_t index = 0) const { return d.data(index); }

	template<typename T>
	inline T dataAs(size_t index = 0) const {
		return *(const T *)d.data(index);
	}

	//! \~english Clear array, remove all elements.
	//! \~russian Очищает массив, удаляет все элементы.
	//! \~\details
	//! \~\note
	//! \~english Reserved memory will not be released.
	//! \~russian Зарезервированная память не освободится.
	//! \~\sa \a resize()
	inline PIByteArray & clear() {
		resize(0);
		return *this;
	}

	//! \~english Assigns element 'e' to all items in the array.
	//! \~russian Заполняет весь массив копиями элемента 'e'.
	//! \~\details
	//! \~\sa \a resize()
	inline PIByteArray & fill(uchar e = 0) {
		d.fill(e);
		return *this;
	}

	//! \~english Assigns result of function 'f(size_t i)' to all items in the array.
	//! \~russian Заполняет весь массив результатом вызова функции 'f(size_t i)'.
	//! \~\details
	//! \~\sa \a resize()
	inline PIByteArray & fill(std::function<uchar(size_t i)> f) {
		d.fill(std::move(f));
		return *this;
	}

	//! \~english Same as \a fill().
	//! \~russian Тоже самое что и \a fill().
	//! \~\sa \a fill(), \a resize()
	inline PIByteArray & assign(uchar e = 0) { return fill(e); }

	//! \~english First does `resize(new_size)` then `fill(e)`.
	//! \~russian Сначала делает `resize(new_size)`, затем `fill(e)`.
	//! \~\sa \a fill(), \a resize()
	inline PIByteArray & assign(size_t new_size, uchar e) {
		resize(new_size);
		return fill(e);
	}

	//! \~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 PIByteArray & resize(size_t new_size, uchar e = 0) {
		d.resize(new_size, e);
		return *this;
	}

	//! \~english Sets size of the array, new elements created by function `f(size_t i)`.
	//! \~russian Устанавливает размер массива, новые элементы создаются функцией `f(size_t i)`.
	//! \~\details
	//! \~english If `new_size` is greater than the current \a size(),
	//!  elements are added to the end; the new elements created by function `f(size_t i)`.
	//! If `new_size` is less than the current \a size(), elements are removed from the end.
	//! \~russian Если `new_size` больше чем текущий размер массива \a size(),
	//! новые элементы добавляются в конец массива и функцией `f(size_t i)`.
	//! Если `new_size` меньше чем текущий размер массива \a size(),
	//! лишние элементы удаляются с конца массива.
	//! \~\sa \a size(), \a clear()
	inline PIByteArray & resize(size_t new_size, std::function<uchar(size_t i)> f) {
		d.resize(new_size, std::move(f));
		return *this;
	}

	//! \~english Return resized byte array
	//! \~russian Возвращает копию байтового массива с измененным размером
	PIByteArray resized(uint new_size) const {
		PIByteArray ret(new_size);
		memcpy(ret.data(), data(), new_size);
		return ret;
	}

	//! \~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 PIByteArray & reserve(size_t new_size) {
		d.reserve(new_size);
		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 PIByteArray & insert(size_t index, uchar e = 0) {
		d.insert(index, 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 PIByteArray & insert(size_t index, const PIByteArray & v) {
		d.insert(index, v.d);
		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 PIByteArray & insert(size_t index, std::initializer_list<uchar> init_list) {
		d.insert(index, init_list);
		return *this;
	}

	//! \~english Removes `count` elements from the middle of the array, starting at `index` position.
	//! \~russian Удаляет элементы из массива, начиная с позиции `index` в количестве `count`.
	//! \~\details
	//! \~\sa \a resize(), \a insert(), \a removeOne(), \a removeAll(), \a removeWhere()
	inline PIByteArray & remove(size_t index, size_t count = 1) {
		d.remove(index, count);
		return *this;
	}

	//! \~english Return sub-array starts from "index" and has "count" or less bytes
	//! \~russian Возвращает подмассив с данными от индекса "index" и размером не более "count"
	PIByteArray getRange(size_t index, size_t count) const { return PIByteArray(d.getRange(index, count)); }

	//! \~english Cut sub-array of this array.
	//! \~russian Вырезает подмассив, то есть кусок из текущего массива.
	//! \~english
	//! \param index - index of this array where sub-array starts
	//! \param count - sub-array size
	//! \~russian
	//! \param index - индекс в текущем массиве, откуда начинётся подмассив
	//! \param count - размер подмассива
	//! \~\details
	//! \~english
	//! Index must be in range from `0` to `size()-1`.
	//! If sub-array size more than this array size, than ends early.
	//! \~russian
	//! Индекс начала должен лежать в диапазоне от `0` до `size()-1`.
	//! Если заданный размер подмассива превышает размер текущего массива,
	//! то вернется подмассив меньшего размера (`size()-index-1`).
	inline PIByteArray takeRange(size_t index, size_t count) { return PIByteArray(d.takeRange(index, count)); }

	//! \~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() на месте переставляет элементы массива,
	//! на котором он был вызван, изменяет массив и возвращает ссылку на него.
	//! Первый элемент массива становится последним, а последний — первым.
	//! \~\sa \a reversed()
	inline PIByteArray & reverse() {
		d.reverse();
		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 PIByteArray reversed() const {
		PIByteArray 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 PIByteArray & enlarge(ssize_t add_size, uchar e = 0) {
		d.enlarge(add_size, e);
		return *this;
	}

	//! \~english Remove no more than one element equal `e`.
	//! \~russian Удаляет первый элемент, который равен элементу `e`.
	//! \~\details
	//! \~\sa \a remove(), \a removeAll(), \a removeWhere()
	inline PIByteArray & removeOne(uchar e) {
		d.removeOne(e);
		return *this;
	}

	//! \~english Remove all elements equal `e`.
	//! \~russian Удаляет все элементы, равные элементу `e`.
	//! \~\details
	//! \~\sa \a remove(), \a removeOne(), \a removeWhere()
	inline PIByteArray & removeAll(uchar e) {
		d.removeAll(e);
		return *this;
	}

	//! \~english Remove all elements in the array
	//! passes the test implemented by the provided function `test`.
	//! \~russian Удаляет все элементы, удовлетворяющие условию,
	//! заданному в передаваемой функции `test`.
	//! \~\details
	//! \~\sa \a remove(), \a removeOne(), \a removeWhere()
	inline PIByteArray & removeWhere(std::function<bool(uchar e)> test) {
		d.removeWhere(std::move(test));
		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(),
	//! то все итераторы и указатели становятся нерабочими.
	//! В противном случае все, кроме итераторов, указывающих на конец массива,
	//! остаются в рабочем состоянии.
	//! \~\sa \a push_front(), \a append(), \a prepend(), \a insert()
	inline PIByteArray & push_back(uchar e) {
		d.push_back(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 PIByteArray & push_back(std::initializer_list<uchar> init_list) {
		d.push_back(init_list);
		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 PIByteArray & push_back(const PIByteArray & v) {
		d.push_back(v.d);
		return *this;
	}


	//! \~english Add to the end data "data" with size "size"
	//! \~russian Добавляет в конец массива данные по указателю "data" размером "size"
	PIByteArray & push_back(const void * data_, int size_) {
		const size_t ps = size();
		enlarge(size_);
		memcpy(data(ps), data_, size_);
		return *this;
	}

	//! \~english Appends the given element `e` to the begin of the array.
	//! \~russian Добавляет элемент `e` в начало массива.
	//! \~\details
	//! \~english If there is free space at the beginning of the array,
	//! 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 there is no free space at the beginning of the array
	//! then all iterators and references
	//! (including the past-the-begin iterator) are invalidated.
	//! Otherwise only the past-the-begin iterator is invalidated.
	//! \~russian Если в начале массива имеется свободное место,
	//! что часто бывает, то добавление будет очень быстрым.
	//! В любом случае добавление быстрое и не зависит от размера массива.
	//! Если в начале массива нет свободного места,
	//! то все итераторы и указатели становятся нерабочими.
	//! В противном случае все, кроме итераторов указывающих, на начало массива,
	//! остаются в рабочем состоянии.
	//! \~\sa \a push_back(), \a append(), \a prepend(), \a insert()
	inline PIByteArray & push_front(uchar e) {
		d.push_front(e);
		return *this;
	}

	//! \~english Appends the given array `v` to the begin of the array.
	//! \~russian Добавляет массив `v` в начало массива.
	//! \~\details
	//! \~english Overloaded function.
	//! \~russian Перегруженая функция.
	//! \~\sa \a push_front()
	inline PIByteArray & push_front(const PIByteArray & v) {
		d.push_front(v.d);
		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 PIByteArray & push_front(std::initializer_list<uchar> init_list) {
		d.push_front(init_list);
		return *this;
	}

	//! \~english Appends the given element `e` to the begin of the array.
	//! \~russian Добавляет элемент `e` в начало массива.
	//! \~\details
	//! \~english If there is free space at the beginning of the array,
	//! 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 there is no free space at the beginning of the array
	//! then all iterators and references
	//! (including the past-the-begin iterator) are invalidated.
	//! Otherwise only the past-the-begin iterator is invalidated.
	//! \~russian Если в начале массива имеется свободное место,
	//! что часто бывает, то добавление будет очень быстрым.
	//! В любом случае добавление быстрое и не зависит от размера массива.
	//! Если в начале массива нет свободного места,
	//! то все итераторы и указатели становятся нерабочими.
	//! В противном случае все, кроме итераторов указывающих, на начало массива,
	//! остаются в рабочем состоянии.
	//! \~\sa \a push_back(), \a append(), \a prepend(), \a insert()
	inline PIByteArray & prepend(uchar e) {
		d.prepend(e);
		return *this;
	}

	//! \~english Appends the given array `v` to the begin of the array.
	//! \~russian Добавляет массив `v` в начало массива.
	//! \~\details
	//! \~english Overloaded function.
	//! \~russian Перегруженая функция.
	//! \~\sa \a prepend()
	inline PIByteArray & prepend(const PIByteArray & v) {
		d.prepend(v.d);
		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 PIByteArray & prepend(std::initializer_list<uchar> init_list) {
		d.prepend(init_list);
		return *this;
	}

	//! \~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 Удаление элемента с конца выполняется очень быстро
	//! и не зависит от размера массива.
	//! \~\sa \a pop_front(), \a take_back(), \a take_front()
	inline PIByteArray & pop_back() {
		d.pop_back();
		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 Удаление элемента с начала выполняется дольше, чем с конца.
	//! Это время прямопропорционально размеру массива.
	//! При удалении элемента все итераторы и указатели становятся нерабочими.
	//! \~\sa \a pop_back(), \a take_back(), \a take_front()
	inline PIByteArray & pop_front() {
		d.pop_front();
		return *this;
	}

	//! \~english Remove one element from the end of the array and return it.
	//! \~russian Удаляет один элемент с начала массива и возвращает его.
	//! \~\details
	//! \~\sa \a take_front(), \a pop_back(), \a pop_front()
	inline uchar take_back() { return d.take_back(); }

	//! \~english Remove one element from the begining of the array and return it.
	//! \~russian Удаляет один элемент с конца массива и возвращает его.
	//! \~\details
	//! \~\sa \a take_front(), \a pop_back(), \a pop_front()
	inline uchar take_front() { return d.take_front(); }

	//! \~english Returns a new array with all elements
	//! that pass the test implemented by the provided function `test`.
	//! \~russian Возвращает новый массив со всеми элементами,
	//! прошедшими проверку, задаваемую в передаваемой функции `test`.
	//! \~\details
	//! \~\code
	//! PIByteArray v{3, 2, 5, 2, 7};
	//! PIByteArray v2 = v.filter([](const uchar & i){return i > 2;});
	//! piCout << v2; // {3, 5, 7}
	//! \endcode
	//! \~\sa \a map(), \a any(), \a every()
	inline PIByteArray filter(std::function<bool(const uchar & e)> test) const { return PIByteArray(d.filter(std::move(test))); }

	//! \~english Execute function `void f(const uchar & e)` for every element in array.
	//! \~russian Выполняет функцию `void f(const uchar & e)` для каждого элемента массива.
	//! \~\details
	//! \~russian Не позволяет изменять элементы массива.
	//! Для редактирования элементов используйте функцию вида `void f(uchar & e)`.
	//! \~english Does not allow changing array elements.
	//! To edit elements, use the function like `void f(T & e)`
	//! \~\code
	//! PIByteArray v{1, 2, 3, 4, 5};
	//! int s = 0;
	//! v.forEach([&s](const uchar & 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 uchar & e)> f) const { d.forEach(std::move(f)); }

	//! \~english Execute function `void f(uchar & e)` for every element in array.
	//! \~russian Выполняет функцию `void f(uchar & e)` для каждого элемента массива.
	//! \~\details
	//! \~english Overloaded function.
	//! Allows you to change the elements of the array.
	//! \~russian Перегруженая функция.
	//! Позволяет изменять элементы массива.
	//! \~\code
	//! PIByteArray v{1, 2, 3, 4, 5};
	//! v.forEach([](uchar & e){e++;});
	//! piCout << v; // {2, 3, 4, 5, 6}
	//! \endcode
	//! \~\sa \a filter(), \a map(), \a reduce(), \a any(), \a every()
	inline PIByteArray & forEach(std::function<void(uchar & e)> f) {
		d.forEach(std::move(f));
		return *this;
	}

	//! \~english Сreates a new array populated with the results
	//! of calling a provided function `ST f(const uchar & e)` on every element in the calling array.
	//! \~russian Создаёт новый массив с результатом вызова указанной функции
	//! `ST f(const T & e)` для каждого элемента массива.
	//! \~\details
	//! \~english Calls a provided function`ST f(const uchar & e)`
	//! once for each element in an array, in order,
	//! and constructs a new array from the results.
	//! \~russian Метод `map` вызывает переданную функцию `ST f(const uchar & e)`
	//! один раз для каждого элемента в порядке их появления
	//! и конструирует новый массив из результатов её вызова.
	//! \~\code
	//! PIByteArray v{0x31, 0x0A, 0xFF};
	//! PIStringList sl = v.map<PIString>([](const uchar & i){return PIString::fromNumber(i, 16);});
	//! piCout << sl; {"31", "A", "FF"}
	//! \endcode
	//! \~\sa \a forEach(), \a reduce()
	template<typename ST>
	inline PIDeque<ST> map(std::function<ST(const uchar & e)> f) const {
		return d.map<ST>(std::move(f));
	}

	//! \~english Applies the function `ST f(const uchar & e, const ST & acc)`
	//! to each element of the array (from left to right), returns one value.
	//! \~russian Применяет функцию `ST f(const uchar & 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 uchar & 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 uchar & e, const ST & acc)`,
	//! выполняющаяся для каждого элемента массива.
	//! Она принимает два аргумента:
	//! * **e** - текущий элемент массива
	//! * **acc** - аккумулятор, аккумулирующий значение
	//! которое возвращает эта функция после посещения очередного элемента
	//!
	//! \param initial _опциональный_ Объект,
	//! используемый в качестве второго аргумента при первом вызове функции `f`.
	//!
	//! \~\code
	//! PIByteArray v{1, 2, 3, 4, 5};
	//! PIString s = v.reduce<PIString>([](const uchar & e, const PIString & acc){return acc + PIString::fromNumber(e);});
	//! piCout << s; // "12345"
	//! \endcode
	//! \~\sa \a forEach(), \a map()
	template<typename ST>
	inline ST reduce(std::function<ST(const uchar & e, const ST & acc)> f, const ST & initial = ST()) const {
		return d.reduce<ST>(std::move(f), initial);
	}

	//! \~english Convert data to Base 64 and return this byte array
	//! \~russian Преобразует данные в Base 64 и возвращает текущий массив
	PIByteArray & convertToBase64();

	//! \~english Convert data from Base 64 and return this byte array
	//! \~russian Преобразует данные из Base 64 и возвращает текущий массив
	PIByteArray & convertFromBase64();

	//! \~english Return converted to Base 64 data
	//! \~russian Возвращает копию байтового массива, преобразованного в Base 64
	PIByteArray toBase64() const;

	PIByteArray & compressRLE(uchar threshold = 192);
	PIByteArray & decompressRLE(uchar threshold = 192);
	PIByteArray compressedRLE(uchar threshold = 192) {
		PIByteArray ba(*this);
		ba.compressRLE(threshold);
		return ba;
	}
	PIByteArray decompressedRLE(uchar threshold = 192) {
		PIByteArray ba(*this);
		ba.decompressRLE(threshold);
		return ba;
	}

	//! \~english Return string representation of data, each byte in "base" base, separated by spaces
	//! \~russian Возвращает текстовое представление байтового массива, каждый байт в "base" системе, с пробелами
	PIString toString(int base = 16) const;

	//! \~english
	//! Returns a hex encoded copy of the byte array, without spaces.
	//! The hex encoding uses the numbers 0-9 and the letters a-f.
	//! \~russian
	//! Возвращает шестнадцатеричное представление массива, без пробелов.
	//! Оно использует цифры 0-9 и буквы a-f.
	PIString toHex() const;

	//! \~english Add to the end data "data" with size "size"
	//! \~russian Добавляет в конец массива данные по указателю "data" размером "size"
	PIByteArray & append(const void * data_, int size_) {
		const size_t ps = size();
		enlarge(size_);
		memcpy(data(ps), data_, size_);
		return *this;
	}

	//! \~english Add to the end byte array "data"
	//! \~russian Добавляет в конец массива содержимое массива "data"
	PIByteArray & append(const PIByteArray & data_) {
#ifdef CC_GCC
#  pragma GCC diagnostic push
#  pragma GCC diagnostic ignored "-Warray-bounds"
#  ifndef ANDROID
#	pragma GCC diagnostic ignored "-Wstringop-overflow"
#	pragma GCC diagnostic ignored "-Wrestrict"
#  endif
#endif
		const size_t ps = size();
		enlarge(data_.size_s());
		memcpy(data(ps), data_.data(), data_.size());
#ifdef CC_GCC
#  pragma GCC diagnostic pop
#endif
		return *this;
	}

	//! \~english Add to the end "t"
	//! \~russian Добавляет в конец массива байт "t"
	PIByteArray & append(uchar t) {
		push_back(t);
		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 PIByteArray & append(std::initializer_list<uchar> init_list) {
		d.append(init_list);
		return *this;
	}

	//! \~english Returns 8-bit checksum
	//! \~russian Возвращает 8-битную контрольную сумму
	uchar checksumPlain8(bool inverse = true) const;

	//! \~english Returns 32-bit checksum
	//! \~russian Возвращает 32-битную контрольную сумму
	uint checksumPlain32(bool inverse = true) const;

	//! \~english Returns 8-bit checksum CRC-8
	//! \~russian Возвращает 8-битную контрольную сумму CRC-8
	uchar checksumCRC8() const;

	//! \~english Returns 16-bit checksum CRC-16
	//! \~russian Возвращает 16-битную контрольную сумму CRC-16
	ushort checksumCRC16() const;

	//! \~english Returns 32-bit checksum CRC-32
	//! \~russian Возвращает 32-битную контрольную сумму CRC-32
	uint checksumCRC32() const;

	//! \~english Returns hash of content
	//! \~russian Возвращает хэш содержимого
	uint hash() const;

	void operator=(const PIDeque<uchar> & o) {
		resize(o.size());
		memcpy(data(), o.data(), o.size());
	}

	PIByteArray & operator=(const PIByteArray & o) {
		if (this == &o) return *this;
		clear();
		append(o);
		return *this;
	}

	PIByteArray & operator=(PIByteArray && o) {
		swap(o);
		return *this;
	}

	static PIByteArray fromUserInput(PIString str);

	static PIByteArray fromHex(PIString str);

	static PIByteArray fromAscii(const char * str);

	//! \~english Return converted from Base 64 data
	//! \~russian Возвращает массив из Base 64 представления
	static PIByteArray fromBase64(const PIByteArray & base64);
	static PIByteArray fromBase64(const PIString & base64);


	bool binaryStreamAppendImp(const void * d_, size_t s) {
		append(d_, s);
		return true;
	}
	bool binaryStreamTakeImp(void * d_, size_t s) {
		const size_t rs = s < size() ? s : size();
		memcpy(d_, data(), rs);
		remove(0, rs);
		return rs == s;
	}

	ssize_t binaryStreamSizeImp() const { return size(); }

private:
	PIDeque<uchar> d;
};

//! \relatesalso PIByteArray
//! \~english Byte arrays compare operator
//! \~russian Оператор сравнения
inline bool operator<(const PIByteArray & v0, const PIByteArray & v1) {
	if (v0.size() == v1.size()) {
		if (v0.isEmpty()) return false;
		return memcmp(v0.data(), v1.data(), v0.size()) < 0;
	}
	return v0.size() < v1.size();
}

//! \relatesalso PIByteArray
//! \~english Byte arrays compare operator
//! \~russian Оператор сравнения
inline bool operator>(const PIByteArray & v0, const PIByteArray & v1) {
	if (v0.size() == v1.size()) {
		if (v0.isEmpty()) return false;
		return memcmp(v0.data(), v1.data(), v0.size()) > 0;
	}
	return v0.size() > v1.size();
}

//! \relatesalso PIByteArray
//! \~english Byte arrays compare operator
//! \~russian Оператор сравнения
inline bool operator==(const PIByteArray & v0, const PIByteArray & v1) {
	if (v0.size() == v1.size()) {
		if (v0.isEmpty()) return true;
		return memcmp(v0.data(), v1.data(), v0.size()) == 0;
	}
	return false;
}

//! \relatesalso PIByteArray
//! \~english Byte arrays compare operator
//! \~russian Оператор сравнения
inline bool operator!=(const PIByteArray & v0, const PIByteArray & v1) {
	if (v0.size() == v1.size()) {
		if (v0.isEmpty()) return false;
		return memcmp(v0.data(), v1.data(), v0.size()) != 0;
	}
	return true;
}

//! \relatesalso PIByteArray
//! \~english Returns bit-wise "and". If non-equal size, then returns empty %PIByteArray.
//! \~russian Возвращает по-битовое "и" Если размеры не совпадают, возвращает пустой %PIByteArray.
inline PIByteArray operator&(const PIByteArray & v0, const PIByteArray & v1) {
	if (v0.size() != v1.size()) return {};
	PIByteArray ret(v0.size(), 0);
	for (uint i = 0; i < v0.size(); ++i)
		ret[i] = v0[i] & v1[i];
	return ret;
}

//! \relatesalso PIByteArray
//! \~english Returns bit-wise "or". If non-equal size, then returns empty %PIByteArray.
//! \~russian Возвращает по-битовое "или" Если размеры не совпадают, возвращает пустой %PIByteArray.
inline PIByteArray operator|(const PIByteArray & v0, const PIByteArray & v1) {
	if (v0.size() != v1.size()) return {};
	PIByteArray ret(v0.size(), 0);
	for (uint i = 0; i < v0.size(); ++i)
		ret[i] = v0[i] | v1[i];
	return ret;
}

//! \relatesalso PIByteArray
//! \~english Returns bit-wise "xor". If non-equal size, then returns empty %PIByteArray.
//! \~russian Возвращает по-битовое "исключающее или" Если размеры не совпадают, возвращает пустой %PIByteArray.
inline PIByteArray operator^(const PIByteArray & v0, const PIByteArray & v1) {
	if (v0.size() != v1.size()) return {};
	PIByteArray ret(v0.size(), 0);
	for (uint i = 0; i < v0.size(); ++i)
		ret[i] = v0[i] ^ v1[i];
	return ret;
}

#ifdef PIP_STD_IOSTREAM
//! \relatesalso PIByteArray \brief Output to std::ostream operator
inline std::ostream & operator<<(std::ostream & s, const PIByteArray & ba);
#endif

//! \relatesalso PIByteArray
//! \~english Output operator to \a PICout
//! \~russian Оператор вывода в \a PICout
PIP_EXPORT PICout operator<<(PICout s, const PIByteArray & ba);


//! \relatesalso PIBinaryStream
//! \~english Store operator.
//! \~russian Оператор сохранения.
BINARY_STREAM_WRITE(PIByteArray) {
	s.binaryStreamAppend((int)v.size_s());
	s.binaryStreamAppend(v.data(), v.size());
	return s;
}

//! \relatesalso PIBinaryStream
//! \~english Restore operator.
//! \~russian Оператор извлечения.
BINARY_STREAM_READ(PIByteArray) {
	v.resize(s.binaryStreamTakeInt());
	s.binaryStreamTake(v.data(), v.size());
	return s;
}


//! \relatesalso PIByteArray
//! \~english Returns PIByteArray::hash() of "ba"
//! \~russian Возвращает PIByteArray::hash() от "ba"
template<>
inline uint piHash(const PIByteArray & ba) {
	return ba.hash();
}

//! \relatesalso PIByteArray
//! \~english Swap contents betwee "f" and "s"
//! \~russian Меняет содержимое массивов "f" и "s"
template<>
inline void piSwap(PIByteArray & f, PIByteArray & s) {
	f.swap(s);
}


//! \relatesalso PIByteArray
//! \~english Store "value" to bytearray and returns it
//! \~russian Сохраняет "value" в байтовый массив и возвращает его
template<typename T>
PIByteArray piSerialize(const T & value) {
	PIByteArray ret;
	ret << value;
	return ret;
}

//! \relatesalso PIByteArray
//! \~english Restore type "T" from bytearray "data" and returns it
//! \~russian Извлекает тип "T" из байтового массива "data" и возвращает его
template<typename T>
T piDeserialize(const PIByteArray & data) {
	T ret;
	if (!data.isEmpty()) {
		PIByteArray ba(data);
		ba >> ret;
	}
	return ret;
}


#endif // PIBYTEARRAY_H
