SHS/pip
4
3
Fork 0
Code Issues 16 Pull Requests 1 Actions Releases Wiki Activity

merged AI doc, some new pages

Browse Source
This commit is contained in:
Пелипенко Иван
2026-03-12 14:46:57 +03:00
parent 07ae277f9e
commit ed13838237
206 changed files with 14088 additions and 5152 deletions
Download Patch File Download Diff File Expand all files Collapse all files

198
libs/main/containers/piset.h
View File

@@ -1,8 +1,10 @@
/*! \file piset.h
* \brief Set container
*
* This file declare PISet
*/
//! \addtogroup Containers
//! \{
//! \~\file piset.h
//! \~\brief
//! \~english Declares \a PISet
//! \~russian Объявление \a PISet
//! \~\}
/*
PIP - Platform Independent Primitives
Set container
@@ -27,13 +29,33 @@
#include "pimap.h"
/*! \brief Set of any type
* \details This class used to store collection of unique elements
* of any type. You can only add values to set with \a operator<< or
* with function \a insert(). You can discover if value already in
* set with \a operator[] or with function \a find(). These function
* has logarithmic complexity.
*/
//! \addtogroup Containers
//! \{
//! \class PISet
//! \~\brief
//! \~english Set of unique values.
//! \~russian Множество уникальных значений.
//! \~\}
//! \~\details
//! \~english
//! This class is used to store a collection of unique elements of any type.
//! You can add values to the set using \a operator<< or the \a insert() function.
//! You can check if a value already exists in the set using \a operator[] or the \a contains() function.
//! These operations have logarithmic complexity.
//! To iterate over all elements, use STL-style iterators \a begin() and \a end().
//!
//! The set is implemented as a wrapper around \a PIMap, where keys are the elements
//! and values are dummy byte values (used only for storage).
//! \~russian
//! Этот класс используется для хранения коллекции уникальных элементов любого типа.
//! Вы можете добавлять значения в множество с помощью \a operator<< или функции \a insert().
//! Вы можете проверить, существует ли значение в множестве, используя \a operator[] или функцию \a contains().
//! Эти операции имеют логарифмическую сложность.
//! Для перебора всех элементов используйте итераторы в стиле STL \a begin() и \a end().
//!
//! Множество реализовано как обёртка над \a PIMap, где ключами являются элементы,
//! а значениями являются фиктивные байтовые значения (используются только для хранения).
//! \~\sa \a PIMap, \a PIVector
template<typename T>
class PISet: public PIMap<T, uchar> {
typedef PIMap<T, uchar> _CSet;
@@ -43,26 +65,31 @@ class PISet: public PIMap<T, uchar> {
friend PIBinaryStream<P> & operator>>(PIBinaryStream<P> & s, PISet<T1> & v);
public:
//! Contructs an empty set
//! \~english Constructs an empty set.
//! \~russian Создает пустое множество.
PISet() {}
//! Contructs set with one element "value"
//! \~english Constructs a set containing `value`.
//! \~russian Создает множество, содержащее `value`.
explicit PISet(const T & value) { _CSet::insert(value, 0); }
//! Contructs set with elements "v0" and "v1"
//! \~english Constructs a set containing `v0` and `v1`.
//! \~russian Создает множество, содержащее `v0` и `v1`.
PISet(const T & v0, const T & v1) {
_CSet::insert(v0, 0);
_CSet::insert(v1, 0);
}
//! Contructs set with elements "v0", "v1" and "v2"
//! \~english Constructs a set containing `v0`, `v1` and `v2`.
//! \~russian Создает множество, содержащее `v0`, `v1` и `v2`.
PISet(const T & v0, const T & v1, const T & v2) {
_CSet::insert(v0, 0);
_CSet::insert(v1, 0);
_CSet::insert(v2, 0);
}
//! Contructs set with elements "v0", "v1", "v2" and "v3"
//! \~english Constructs a set containing `v0`, `v1`, `v2` and `v3`.
//! \~russian Создает множество, содержащее `v0`, `v1`, `v2` и `v3`.
PISet(const T & v0, const T & v1, const T & v2, const T & v3) {
_CSet::insert(v0, 0);
_CSet::insert(v1, 0);
@@ -71,6 +98,9 @@ public:
}
//! \~\brief
//! \~english Constant iterator over \a PISet elements.
//! \~russian Константный итератор по элементам \a PISet.
class const_iterator {
friend class PISet<T>;
@@ -86,75 +116,140 @@ public:
typedef std::ptrdiff_t difference_type;
typedef std::random_access_iterator_tag iterator_category;
//! \~english Constructs an invalid iterator.
//! \~russian Создает недействительный итератор.
inline const_iterator(): parent(0), pos(0) {}
//! \~english Returns the current element.
//! \~russian Возвращает текущий элемент.
inline const T & operator*() const { return parent->pim_index[pos].key; }
//! \~english Provides access to the current element.
//! \~russian Предоставляет доступ к текущему элементу.
inline const T & operator->() const { return parent->pim_index[pos].key; }
//! \~english Moves iterator to the next element.
//! \~russian Перемещает итератор к следующему элементу.
inline const_iterator & operator++() {
++pos;
return *this;
}
//! \~english Returns iterator before incrementing.
//! \~russian Возвращает итератор до увеличения.
inline const_iterator operator++(int) {
const auto tmp = *this;
++*this;
return tmp;
}
//! \~english Moves iterator to the previous element.
//! \~russian Перемещает итератор к предыдущему элементу.
inline const_iterator & operator--() {
--pos;
return *this;
}
//! \~english Returns iterator before decrementing.
//! \~russian Возвращает итератор до уменьшения.
inline const_iterator operator--(int) {
const auto tmp = *this;
--*this;
return tmp;
}
//! \~english Adds offset of iterator `it`.
//! \~russian Добавляет смещение итератора `it`.
inline const_iterator & operator+=(const const_iterator & it) {
pos += it.pos;
return *this;
}
//! \~english Advances iterator by `p` elements.
//! \~russian Сдвигает итератор вперед на `p` элементов.
inline const_iterator & operator+=(size_t p) {
pos += p;
return *this;
}
//! \~english Subtracts offset of iterator `it`.
//! \~russian Вычитает смещение итератора `it`.
inline const_iterator & operator-=(const const_iterator & it) {
pos -= it.pos;
return *this;
}
//! \~english Moves iterator back by `p` elements.
//! \~russian Сдвигает итератор назад на `p` элементов.
inline const_iterator & operator-=(size_t p) {
pos -= p;
return *this;
}
//! \~english Returns iterator shifted back by `p`.
//! \~russian Возвращает итератор, сдвинутый назад на `p`.
friend inline const_iterator operator-(size_t p, const const_iterator & it) { return it - p; }
//! \~english Returns iterator shifted back by `p`.
//! \~russian Возвращает итератор, сдвинутый назад на `p`.
friend inline const_iterator operator-(const const_iterator & it, size_t p) {
auto tmp = it;
tmp -= p;
return tmp;
}
//! \~english Returns distance between iterators.
//! \~russian Возвращает расстояние между итераторами.
friend inline std::ptrdiff_t operator-(const const_iterator & it1, const const_iterator & it2) { return it1.pos - it2.pos; }
//! \~english Returns iterator shifted forward by `p`.
//! \~russian Возвращает итератор, сдвинутый вперед на `p`.
friend inline const_iterator operator+(size_t p, const const_iterator & it) { return it + p; }
//! \~english Returns iterator shifted forward by `p`.
//! \~russian Возвращает итератор, сдвинутый вперед на `p`.
friend inline const_iterator operator+(const const_iterator & it, size_t p) {
auto tmp = it;
tmp += p;
return tmp;
}
//! \~english Checks iterator equality.
//! \~russian Проверяет равенство итераторов.
inline bool operator==(const const_iterator & it) const { return (pos == it.pos); }
//! \~english Checks iterator inequality.
//! \~russian Проверяет неравенство итераторов.
inline bool operator!=(const const_iterator & it) const { return (pos != it.pos); }
//! \~english Checks whether `it1` is before `it2`.
//! \~russian Проверяет, находится ли `it1` перед `it2`.
friend inline bool operator<(const const_iterator & it1, const const_iterator & it2) { return it1.pos < it2.pos; }
//! \~english Checks whether `it1` is before or equal to `it2`.
//! \~russian Проверяет, находится ли `it1` перед `it2` или совпадает с ним.
friend inline bool operator<=(const const_iterator & it1, const const_iterator & it2) { return it1.pos <= it2.pos; }
//! \~english Checks whether `it1` is after `it2`.
//! \~russian Проверяет, находится ли `it1` после `it2`.
friend inline bool operator>(const const_iterator & it1, const const_iterator & it2) { return it1.pos > it2.pos; }
//! \~english Checks whether `it1` is after or equal to `it2`.
//! \~russian Проверяет, находится ли `it1` после `it2` или совпадает с ним.
friend inline bool operator>=(const const_iterator & it1, const const_iterator & it2) { return it1.pos >= it2.pos; }
};
//! \~english Returns iterator to the first element.
//! \~russian Возвращает итератор на первый элемент.
inline const_iterator begin() const { return const_iterator(this, 0); }
//! \~english Returns iterator following the last element.
//! \~russian Возвращает итератор на элемент, следующий за последним.
inline const_iterator end() const { return const_iterator(this, _CSet::size()); }
//! Contructs set from vector of elements
//! \~english Constructs a set from vector `values`.
//! \~russian Создает множество из вектора `values`.
explicit PISet(const PIVector<T> & values) {
if (values.isEmpty()) return;
for (int i = 0; i < values.size_s(); ++i) {
@@ -162,7 +257,8 @@ public:
}
}
//! Contructs set from deque of elements
//! \~english Constructs a set from deque `values`.
//! \~russian Создает множество из дека `values`.
explicit PISet(const PIDeque<T> & values) {
if (values.isEmpty()) return;
for (int i = 0; i < values.size_s(); ++i) {
@@ -172,65 +268,83 @@ public:
typedef T key_type;
//! \~english Inserts `t` into the set.
//! \~russian Добавляет `t` в множество.
PISet<T> & operator<<(const T & t) {
_CSet::insert(t, 0);
return *this;
}
//! \~english Moves `t` into the set.
//! \~russian Перемещает `t` в множество.
PISet<T> & operator<<(T && t) {
_CSet::insert(std::move(t), 0);
return *this;
}
//! \~english Inserts all elements from `other`.
//! \~russian Добавляет все элементы из `other`.
PISet<T> & operator<<(const PISet<T> & other) {
(*(_CSet *)this) << *((_CSet *)&other);
return *this;
}
//! \~english Tests if element `key` exists in the set.
//! \~russian Проверяет наличие элемента `key` в массиве.
//! \~english Tests whether element `t` exists in the set.
//! \~russian Проверяет наличие элемента `t` в множестве.
inline bool contains(const T & t) const { return _CSet::contains(t); }
//! Returns if element "t" exists in this set
//! \~english Checks whether element `t` exists in the set.
//! \~russian Проверяет наличие элемента `t` в множестве.
bool operator[](const T & t) const { return _CSet::contains(t); }
//! Returns if element "t" exists in this set
//! \~english Removes element `t` from the set.
//! \~russian Удаляет элемент `t` из множества.
PISet<T> & remove(const T & t) {
_CSet::remove(t);
return *this;
}
//! Unite set with "v"
//! \~english Unites the set with `v`.
//! \~russian Объединяет множество с `v`.
PISet<T> & unite(const PISet<T> & v) {
for (const auto & i: v)
_CSet::insert(i, 0);
return *this;
}
//! Subtract set with "v"
//! \~english Removes all elements present in `v`.
//! \~russian Удаляет все элементы, присутствующие в `v`.
PISet<T> & subtract(const PISet<T> & v) {
for (const auto & i: v)
_CSet::remove(i);
return *this;
}
//! Intersect set with "v"
//! \~english Leaves only elements also present in `v`.
//! \~russian Оставляет только элементы, которые есть и в `v`.
PISet<T> & intersect(const PISet<T> & v) {
_CSet::removeWhere([&v](const T & k, uchar) { return !v.contains(k); });
return *this;
}
//! Unite set with "v"
//! \~english Same as \a unite().
//! \~russian Синоним \a unite().
PISet<T> & operator+=(const PISet<T> & v) { return unite(v); }
//! Unite set with "v"
//! \~english Same as \a unite().
//! \~russian Синоним \a unite().
PISet<T> & operator|=(const PISet<T> & v) { return unite(v); }
//! Subtract set with "v"
//! \~english Same as \a subtract().
//! \~russian Синоним \a subtract().
PISet<T> & operator-=(const PISet<T> & v) { return subtract(v); }
//! Intersect set with "v"
//! \~english Same as \a intersect().
//! \~russian Синоним \a intersect().
PISet<T> & operator&=(const PISet<T> & v) { return intersect(v); }
//! Returns content of set as PIVector
//! \~english Returns set contents as \a PIVector.
//! \~russian Возвращает содержимое множества в виде \a PIVector.
PIVector<T> toVector() const {
PIVector<T> ret;
for (const auto & i: *this)
@@ -238,7 +352,8 @@ public:
return ret;
}
//! Returns content of set as PIDeque
//! \~english Returns set contents as \a PIDeque.
//! \~russian Возвращает содержимое множества в виде \a PIDeque.
PIDeque<T> toDeque() const {
PIDeque<T> ret;
for (const auto & i: *this)
@@ -248,7 +363,9 @@ public:
};
//! \relatesalso PISet \brief Returns unite of two sets
//! \relatesalso PISet
//! \~english Returns union of two sets.
//! \~russian Возвращает объединение двух множеств.
template<typename T>
PISet<T> operator+(const PISet<T> & v0, const PISet<T> & v1) {
PISet<T> ret(v0);
@@ -256,7 +373,9 @@ PISet<T> operator+(const PISet<T> & v0, const PISet<T> & v1) {
return ret;
}
//! \relatesalso PISet \brief Returns subtraction of two sets
//! \relatesalso PISet
//! \~english Returns difference of two sets.
//! \~russian Возвращает разность двух множеств.
template<typename T>
PISet<T> operator-(const PISet<T> & v0, const PISet<T> & v1) {
PISet<T> ret(v0);
@@ -264,7 +383,9 @@ PISet<T> operator-(const PISet<T> & v0, const PISet<T> & v1) {
return ret;
}
//! \relatesalso PISet \brief Returns unite of two sets
//! \relatesalso PISet
//! \~english Returns union of two sets.
//! \~russian Возвращает объединение двух множеств.
template<typename T>
PISet<T> operator|(const PISet<T> & v0, const PISet<T> & v1) {
PISet<T> ret(v0);
@@ -272,7 +393,9 @@ PISet<T> operator|(const PISet<T> & v0, const PISet<T> & v1) {
return ret;
}
//! \relatesalso PISet \brief Returns intersetion of two sets
//! \relatesalso PISet
//! \~english Returns intersection of two sets.
//! \~russian Возвращает пересечение двух множеств.
template<typename T>
PISet<T> operator&(const PISet<T> & v0, const PISet<T> & v1) {
PISet<T> ret(v0);
@@ -281,6 +404,9 @@ PISet<T> operator&(const PISet<T> & v0, const PISet<T> & v1) {
}
//! \relatesalso PISet
//! \~english Output operator to \a PICout.
//! \~russian Оператор вывода в \a PICout.
template<typename Type>
inline PICout operator<<(PICout s, const PISet<Type> & v) {
s.space();