From 99061f6e241f8d9df8e611b52b77a2bd4b931fdd Mon Sep 17 00:00:00 2001
From: Andrey <a.bychkov@itelma.su>
Date: Mon, 14 Mar 2022 12:46:13 +0300
Subject: [PATCH] utf-8

---
 libs/main/core/pibase.h | 266 ++++++++++++++++++++--------------------
 1 file changed, 133 insertions(+), 133 deletions(-)

diff --git a/libs/main/core/pibase.h b/libs/main/core/pibase.h
index ea18e8d1..d3f1cd57 100644
--- a/libs/main/core/pibase.h
+++ b/libs/main/core/pibase.h
@@ -1,15 +1,15 @@
 /*! @file pibase.h
  * \brief
  * \~english Base types and functions
- * \~russian Базовые типы и методы
+ * \~russian Базовые типы и методы
  *
  * \details
  * \~english
  * This file implements first layer above the system and
  * declares some basic useful functions
  * \~russian
- * Этот файл реализует первый слой после системы и объявляет
- * несколько базовых полезных методов
+ * Этот файл реализует первый слой после системы и объявляет
+ * несколько базовых полезных методов
 */
 /*
 	PIP - Platform Independent Primitives
@@ -43,9 +43,9 @@
 //! Parsing by \a pip_cmg and can be accessed by \a PICodeInfo.
 //! Contains sequence of key=value pairs, e.g.
 //! \~russian
-//! Секция метаинформации для любой сущности.
-//! Парсится \a pip_cmg и доступна с помощью \a PICodeInfo.
-//! Содержит набор пар ключ=значение, например
+//! Секция метаинформации для любой сущности.
+//! Парсится \a pip_cmg и доступна с помощью \a PICodeInfo.
+//! Содержит набор пар ключ=значение, например
 //! \~
 //! PIMETA(id=12345,tag="my string")
 #define PIMETA(...)
@@ -54,127 +54,127 @@
 
 //! \brief
 //! \~english Major value of PIP version
-//! \~russian Мажорная версия PIP
+//! \~russian Мажорная версия PIP
 #  define PIP_VERSION_MAJOR
 
 //! \brief
 //! \~english Minor value of PIP version
-//! \~russian Минорная версия PIP
+//! \~russian Минорная версия PIP
 #  define PIP_VERSION_MINOR
 
 //! \brief
 //! \~english Revision value of PIP version
-//! \~russian Ревизия версии PIP
+//! \~russian Ревизия версии PIP
 #  define PIP_VERSION_REVISION
 
 //! \brief
 //! \~english Suffix of PIP version
-//! \~russian Суффикс версии PIP
+//! \~russian Суффикс версии PIP
 #  define PIP_VERSION_SUFFIX
 
 //! \brief
 //! \~english Version of PIP in hex - 0x##(Major)##(Minor)##(Revision)
-//! \~russian Версия PIP в hex - 0x##(Major)##(Minor)##(Revision)
+//! \~russian Версия PIP в hex - 0x##(Major)##(Minor)##(Revision)
 #  define PIP_VERSION
 
 //! \brief
 //! \~english Macro is defined when compile-time debug is enabled
-//! \~russian Макрос объявлен когда включена compile-time отладка
+//! \~russian Макрос объявлен когда включена compile-time отладка
 #  define PIP_DEBUG
 
 //! \brief
 //! \~english Macro is defined when host is any Windows
-//! \~russian Макрос объявлен когда система Windows
+//! \~russian Макрос объявлен когда система Windows
 #  define WINDOWS
 
 //! \brief
 //! \~english Macro is defined when host is QNX or Blackberry
-//! \~russian Макрос объявлен когда система QNX или Blackberry
+//! \~russian Макрос объявлен когда система QNX или Blackberry
 #  define QNX
 
 //! \brief
 //! \~english Macro is defined when host is Blackberry
-//! \~russian Макрос объявлен когда система Blackberry
+//! \~russian Макрос объявлен когда система Blackberry
 #  define BLACKBERRY
 
 //! \brief
 //! \~english Macro is defined when host is FreeBSD
-//! \~russian Макрос объявлен когда система FreeBSD
+//! \~russian Макрос объявлен когда система FreeBSD
 #  define FREE_BSD
 
 //! \brief
 //! \~english Macro is defined when host is Mac OS
-//! \~russian Макрос объявлен когда система Mac OS
+//! \~russian Макрос объявлен когда система Mac OS
 #  define MAC_OS
 
 //! \brief
 //! \~english Macro is defined when host is Android
-//! \~russian Макрос объявлен когда система Android
+//! \~russian Макрос объявлен когда система Android
 #  define ANDROID
 
 //! \brief
 //! \~english Macro is defined when host is any Linux
-//! \~russian Макрос объявлен когда система Linux
+//! \~russian Макрос объявлен когда система Linux
 #  define LINUX
 
 //! \brief
 //! \~english Macro is defined when compiler is GCC or MinGW
-//! \~russian Макрос объявлен когда компилятор GCC или MinGW
+//! \~russian Макрос объявлен когда компилятор GCC или MinGW
 #  define CC_GCC
 
 //! \brief
 //! \~english Macro is defined when PIP is decided that host is support language
-//! \~russian Макрос объявлен когда PIP решил что система поддерживает локализацию
+//! \~russian Макрос объявлен когда PIP решил что система поддерживает локализацию
 #  define HAS_LOCALE
 
 //! \brief
 //! \~english Macro is defined when compiler is Visual Studio
-//! \~russian Макрос объявлен когда компилятор Visual Studio
+//! \~russian Макрос объявлен когда компилятор Visual Studio
 #  define CC_VC
 
 //! \brief
 //! \~english Macro is defined when compiler is unknown
-//! \~russian Макрос объявлен когда компилятор неизвестен
+//! \~russian Макрос объявлен когда компилятор неизвестен
 #  define CC_OTHER
 
 //! \brief
 //! \~english Macro is defined when PIP can use "rt" library for "PITimer::ThreadRT" timers implementation
-//! \~russian Макрос объявлен когда PIP может использовать библиотеку "rt" для "PITimer::ThreadRT" реализации таймера
+//! \~russian Макрос объявлен когда PIP может использовать библиотеку "rt" для "PITimer::ThreadRT" реализации таймера
 #  define PIP_TIMER_RT
 
 //! \brief
 //! \~english Macro to declare private section, "export" is optional
-//! \~russian Макрос для объявления частной секции, "export" необязателен
+//! \~russian Макрос для объявления частной секции, "export" необязателен
 #  define PRIVATE_DECLARATION(export)
 
 //! \brief
 //! \~english Macro to start definition of private section
-//! \~russian Макрос для начала реализации частной секции
+//! \~russian Макрос для начала реализации частной секции
 #  define PRIVATE_DEFINITION_START(Class)
 
 //! \brief
 //! \~english Macro to end definition of private section
-//! \~russian Макрос для окончания реализации частной секции
+//! \~russian Макрос для окончания реализации частной секции
 #  define PRIVATE_DEFINITION_END(Class)
 
 //! \brief
 //! \~english Macro to access private section by pointer
-//! \~russian Макрос для доступа к частной секции
+//! \~russian Макрос для доступа к частной секции
 #  define PRIVATE
 
 //! \brief
 //! \~english Macro to access private section by pointer without brakes ()
-//! \~russian Макрос для доступа к частной секции без обрамляющих скобок ()
+//! \~russian Макрос для доступа к частной секции без обрамляющих скобок ()
 #  define PRIVATEWB
 
 //! \brief
 //! \~english Macro to start static initializer
-//! \~russian Макрос для начала статической инициализации
+//! \~russian Макрос для начала статической инициализации
 #  define STATIC_INITIALIZER_BEGIN
 
 //! \brief
 //! \~english Macro to end static initializer
-//! \~russian Макрос для окончания статической инициализации
+//! \~russian Макрос для окончания статической инициализации
 #  define STATIC_INITIALIZER_END
 
 
@@ -352,30 +352,30 @@
 
 //! \brief
 //! \~english Macro used for infinite loop
-//! \~russian Макрос для бесконечного цикла
+//! \~russian Макрос для бесконечного цикла
 #define FOREVER for (;;)
 
 //! \brief
 //! \~english Macro used for infinite wait
-//! \~russian Макрос для бесконечного ожидания
+//! \~russian Макрос для бесконечного ожидания
 #define FOREVER_WAIT FOREVER piMinSleep;
 
 //! \brief
 //! \~english Macro used for infinite wait
-//! \~russian Макрос для бесконечного ожидания
+//! \~russian Макрос для бесконечного ожидания
 #define WAIT_FOREVER FOREVER piMinSleep;
 
 
 //! \brief
 //! \~english Global variable enabling output to piCout, default is true
-//! \~russian Глобальная переменная, включающая вывод в piCout, при старте true
+//! \~russian Глобальная переменная, включающая вывод в piCout, при старте true
 extern PIP_EXPORT bool piDebug;
 
 //! \brief
 //! \~english Global variable that set minimum real update interval
 //! for function PIInit::mountInfo(), default is 10000 ms
-//! \~russian Глобальная переменная минимального ожидания между реальным обновлением
-//! в методе PIInit::mountInfo(), по умолчанию 10000 мс
+//! \~russian Глобальная переменная минимального ожидания между реальным обновлением
+//! в методе PIInit::mountInfo(), по умолчанию 10000 мс
 extern PIP_EXPORT double piMountInfoRefreshIntervalMs;
 
 typedef unsigned char uchar;
@@ -388,18 +388,18 @@ typedef long double ldouble;
 
 //! \brief
 //! \~english Templated function for swap two values
-//! \~russian Шаблонный метод для перестановки двух значений
+//! \~russian Шаблонный метод для перестановки двух значений
 //! \details
 //! \~english Example:\n \snippet piincludes.cpp swap
-//! \~russian Пример:\n \snippet piincludes.cpp swap
+//! \~russian Пример:\n \snippet piincludes.cpp swap
 template<typename T> inline void piSwap(T & f, T & s) {T t(std::move(f)); f = std::move(s); s = std::move(t);}
 
 //! \brief
 //! \~english Templated function for swap two values without "="
-//! \~russian Шаблонный метод для перестановки двух значений без использования "="
+//! \~russian Шаблонный метод для перестановки двух значений без использования "="
 //! \details
 //! \~english Example:\n \snippet piincludes.cpp swapBinary
-//! \~russian Пример:\n \snippet piincludes.cpp swapBinary
+//! \~russian Пример:\n \snippet piincludes.cpp swapBinary
 template<typename T> inline void piSwapBinary(T & f, T & s) {
 	if ((size_t*)&f == (size_t*)&s) return;
 	size_t j = (sizeof(T) / sizeof(size_t)), bs = j * sizeof(size_t), bf = sizeof(T);
@@ -436,10 +436,10 @@ template<> inline void piSwapBinary(const void *& f, const void *& s) {
 
 //! \brief
 //! \~english Function for compare two values without "==" by raw content
-//! \~russian Метод для сравнения двух значений без использования "==" (по сырому содержимому)
+//! \~russian Метод для сравнения двух значений без использования "==" (по сырому содержимому)
 //! \details
 //! \~english Example:\n \snippet piincludes.cpp compareBinary
-//! \~russian Пример:\n \snippet piincludes.cpp compareBinary
+//! \~russian Пример:\n \snippet piincludes.cpp compareBinary
 inline bool piCompareBinary(const void * f, const void * s, size_t size) {
 	for (size_t i = 0; i < size; ++i)
 		if (((const uchar*)f)[i] != ((const uchar*)s)[i])
@@ -449,7 +449,7 @@ inline bool piCompareBinary(const void * f, const void * s, size_t size) {
 
 //! \brief
 //! \~english Templated function return round of float falue
-//! \~russian Шаблонный метод, возвращающий округленное значение
+//! \~russian Шаблонный метод, возвращающий округленное значение
 //! \details
 //! \~english
 //! Round is the nearest integer value \n
@@ -460,18 +460,18 @@ inline bool piCompareBinary(const void * f, const void * s, size_t size) {
 //! Example:
 //! \snippet piincludes.cpp round
 //! \~russian
-//! Округленное значение - это ближайшее целое число\n
-//! Есть несколько макросов:
-//! - \c piRoundf для "float"
-//! - \c piRoundd для "double"
+//! Округленное значение - это ближайшее целое число\n
+//! Есть несколько макросов:
+//! - \c piRoundf для "float"
+//! - \c piRoundd для "double"
 //!
-//! Пример:
+//! Пример:
 //! \snippet piincludes.cpp round
 template<typename T> inline constexpr int piRound(const T & v) {return int(v >= T(0.) ? v + T(0.5) : v - T(0.5));}
 
 //! \brief
 //! \~english Templated function return floor of float falue
-//! \~russian Шаблонный метод, возвращающий floor значение
+//! \~russian Шаблонный метод, возвращающий floor значение
 //! \details
 //! \~english
 //! Floor is the largest integer that is not greater than "v" \n
@@ -482,18 +482,18 @@ template<typename T> inline constexpr int piRound(const T & v) {return int(v >=
 //! Example:
 //! \snippet piincludes.cpp floor
 //! \~russian
-//! Floor значение - это наибольшее целое, не большее чем "v"\n
-//! Есть несколько макросов:
-//! - \c piFloorf для "float"
-//! - \c piFloord для "double"
+//! Floor значение - это наибольшее целое, не большее чем "v"\n
+//! Есть несколько макросов:
+//! - \c piFloorf для "float"
+//! - \c piFloord для "double"
 //!
-//! Пример:
+//! Пример:
 //! \snippet piincludes.cpp floor
 template<typename T> inline constexpr int piFloor(const T & v) {return v < T(0) ? int(v) - 1 : int(v);}
 
 //! \brief
 //! \~english Templated function return ceil of float falue
-//! \~russian Шаблонный метод, возвращающий ceil значение
+//! \~russian Шаблонный метод, возвращающий ceil значение
 //! \details
 //! \~english
 //! Ceil is the smallest integer that is not less than "v" \n
@@ -504,18 +504,18 @@ template<typename T> inline constexpr int piFloor(const T & v) {return v < T(0)
 //! Example:
 //! \snippet piincludes.cpp ceil
 //! \~russian
-//! Ceil значение - это наименьшее целое, не меньшее чем "v" \n
-//! Есть несколько макросов:
-//! - \c piCeilf для "float"
-//! - \c piCeild для "double"
+//! Ceil значение - это наименьшее целое, не меньшее чем "v" \n
+//! Есть несколько макросов:
+//! - \c piCeilf для "float"
+//! - \c piCeild для "double"
 //!
-//! Пример:
+//! Пример:
 //! \snippet piincludes.cpp ceil
 template<typename T> inline constexpr int piCeil(const T & v) {return v < T(0) ? int(v) : int(v) + 1;}
 
 //! \brief
 //! \~english Templated function return absolute of numeric falue
-//! \~russian Шаблонный метод, возвращающий модуль числового значения
+//! \~russian Шаблонный метод, возвращающий модуль числового значения
 //! \details
 //! \~english
 //! Absolute is the positive or equal 0 value \n
@@ -530,22 +530,22 @@ template<typename T> inline constexpr int piCeil(const T & v) {return v < T(0) ?
 //! Example:
 //! \snippet piincludes.cpp abs
 //! \~russian
-//! Модуль числового значения всегда >= 0 \n
-//! Есть несколько макросов:
-//! - \c piAbss для "short"
-//! - \c piAbsi для "int"
-//! - \c piAbsl для "long"
-//! - \c piAbsll для "llong"
-//! - \c piAbsf для "float"
-//! - \c piAbsd для "double"
+//! Модуль числового значения всегда >= 0 \n
+//! Есть несколько макросов:
+//! - \c piAbss для "short"
+//! - \c piAbsi для "int"
+//! - \c piAbsl для "long"
+//! - \c piAbsll для "llong"
+//! - \c piAbsf для "float"
+//! - \c piAbsd для "double"
 //!
-//! Пример:
+//! Пример:
 //! \snippet piincludes.cpp abs
 template<typename T> inline constexpr T piAbs(const T & v) {return (v >= T(0) ? v : -v);}
 
 //! \brief
 //! \~english Templated function return minimum of two values
-//! \~russian Шаблонный метод, возвращающий минимум из двух значений
+//! \~russian Шаблонный метод, возвращающий минимум из двух значений
 //! \details
 //! \~english
 //! There are some macros:
@@ -559,21 +559,21 @@ template<typename T> inline constexpr T piAbs(const T & v) {return (v >= T(0) ?
 //! Example:
 //! \snippet piincludes.cpp min2
 //! \~russian
-//! Есть несколько макросов:
-//! - \c piMins для "short"
-//! - \c piMini для "int"
-//! - \c piMinl для "long"
-//! - \c piMinll для "llong"
-//! - \c piMinf для "float"
-//! - \c piMind для "double"
+//! Есть несколько макросов:
+//! - \c piMins для "short"
+//! - \c piMini для "int"
+//! - \c piMinl для "long"
+//! - \c piMinll для "llong"
+//! - \c piMinf для "float"
+//! - \c piMind для "double"
 //!
-//! Пример:
+//! Пример:
 //! \snippet piincludes.cpp min2
 template<typename T> inline constexpr T piMin(const T & f, const T & s) {return ((f > s) ? s : f);}
 
 //! \brief
 //! \~english Templated function return minimum of tree values
-//! \~russian Шаблонный метод, возвращающий минимум из трех значений
+//! \~russian Шаблонный метод, возвращающий минимум из трех значений
 //! \details
 //! \~english
 //! There are some macros:
@@ -587,21 +587,21 @@ template<typename T> inline constexpr T piMin(const T & f, const T & s) {return
 //! Example:
 //! \snippet piincludes.cpp min3
 //! \~russian
-//! Есть несколько макросов:
-//! - \c piMins для "short"
-//! - \c piMini для "int"
-//! - \c piMinl для "long"
-//! - \c piMinll для "llong"
-//! - \c piMinf для "float"
-//! - \c piMind для "double"
+//! Есть несколько макросов:
+//! - \c piMins для "short"
+//! - \c piMini для "int"
+//! - \c piMinl для "long"
+//! - \c piMinll для "llong"
+//! - \c piMinf для "float"
+//! - \c piMind для "double"
 //!
-//! Пример:
+//! Пример:
 //! \snippet piincludes.cpp min3
 template<typename T> inline constexpr T piMin(const T & f, const T & s, const T & t) {return ((f < s && f < t) ? f : ((s < t) ? s : t));}
 
 //! \brief
 //! \~english Templated function return maximum of two values
-//! \~russian Шаблонный метод, возвращающий максимум из двух значений
+//! \~russian Шаблонный метод, возвращающий максимум из двух значений
 //! \details
 //! \~english
 //! There are some macros:
@@ -615,21 +615,21 @@ template<typename T> inline constexpr T piMin(const T & f, const T & s, const T
 //! Example:
 //! \snippet piincludes.cpp max2
 //! \~russian
-//! Есть несколько макросов:
-//! - \c piMaxs для "short"
-//! - \c piMaxi для "int"
-//! - \c piMaxl для "long"
-//! - \c piMaxll для "llong"
-//! - \c piMaxf для "float"
-//! - \c piMaxd для "double"
+//! Есть несколько макросов:
+//! - \c piMaxs для "short"
+//! - \c piMaxi для "int"
+//! - \c piMaxl для "long"
+//! - \c piMaxll для "llong"
+//! - \c piMaxf для "float"
+//! - \c piMaxd для "double"
 //!
-//! Пример:
+//! Пример:
 //! \snippet piincludes.cpp max2
 template<typename T> inline constexpr T piMax(const T & f, const T & s) {return ((f < s) ? s : f);}
 
 //! \brief
 //! \~english Templated function return maximum of tree values
-//! \~russian Шаблонный метод, возвращающий максимум из трех значений
+//! \~russian Шаблонный метод, возвращающий максимум из трех значений
 //! \details
 //! \~english
 //! There are some macros:
@@ -643,21 +643,21 @@ template<typename T> inline constexpr T piMax(const T & f, const T & s) {return
 //! Example:
 //! \snippet piincludes.cpp max3
 //! \~russian
-//! Есть несколько макросов:
-//! - \c piMaxs для "short"
-//! - \c piMaxi для "int"
-//! - \c piMaxl для "long"
-//! - \c piMaxll для "llong"
-//! - \c piMaxf для "float"
-//! - \c piMaxd для "double"
+//! Есть несколько макросов:
+//! - \c piMaxs для "short"
+//! - \c piMaxi для "int"
+//! - \c piMaxl для "long"
+//! - \c piMaxll для "llong"
+//! - \c piMaxf для "float"
+//! - \c piMaxd для "double"
 //!
-//! Пример:
+//! Пример:
 //! \snippet piincludes.cpp max3
 template<typename T> inline constexpr T piMax(const T & f, const T & s, const T & t) {return ((f > s && f > t) ? f : ((s > t) ? s : t));}
 
 //! \brief
 //! \~english Templated function return clamped value
-//! \~russian Шаблонный метод, возвращающий ограниченное значение
+//! \~russian Шаблонный метод, возвращающий ограниченное значение
 //! \details
 //! \~english
 //! Clamped is the not greater than "max" and not lesser than "min" value \n
@@ -672,22 +672,22 @@ template<typename T> inline constexpr T piMax(const T & f, const T & s, const T
 //! Example:
 //! \snippet piincludes.cpp clamp
 //! \~russian
-//! Ограниченное значение - не больше чем "max" и не меньше чем "min"
-//! Есть несколько макросов:
-//! - \c piClamps для "short"
-//! - \c piClampi для "int"
-//! - \c piClampl для "long"
-//! - \c piClampll для "llong"
-//! - \c piClampf для "float"
-//! - \c piClampd для "double"
+//! Ограниченное значение - не больше чем "max" и не меньше чем "min"
+//! Есть несколько макросов:
+//! - \c piClamps для "short"
+//! - \c piClampi для "int"
+//! - \c piClampl для "long"
+//! - \c piClampll для "llong"
+//! - \c piClampf для "float"
+//! - \c piClampd для "double"
 //!
-//! Пример:
+//! Пример:
 //! \snippet piincludes.cpp clamp
 template<typename T> inline constexpr T piClamp(const T & v, const T & min, const T & max) {return (v > max ? max : (v < min ? min : v));}
 
 //! \brief
 //! \~english Function inverse byte order in memory block ([1..N] -> [N..1])
-//! \~russian Метод для смены порядка байт в блоке памяти ([1..N] -> [N..1])
+//! \~russian Метод для смены порядка байт в блоке памяти ([1..N] -> [N..1])
 inline void piLetobe(void * data, int size) {
 	for (int i = 0; i < size / 2; i++)
 		piSwap<uchar>(((uchar*)data)[size - i - 1], ((uchar*)data)[i]);
@@ -695,7 +695,7 @@ inline void piLetobe(void * data, int size) {
 
 //! \brief
 //! \~english Function for compare two numeric values with epsilon
-//! \~russian Метод для сравнения двух чисел с порогом
+//! \~russian Метод для сравнения двух чисел с порогом
 //! \details
 //! \~english
 //! There are some macros:
@@ -705,11 +705,11 @@ inline void piLetobe(void * data, int size) {
 //! Example:
 //! \snippet piincludes.cpp compare
 //! \~russian
-//! Есть несколько макросов:
-//! - \c piComparef для "float"
-//! - \c piCompared для "double"
+//! Есть несколько макросов:
+//! - \c piComparef для "float"
+//! - \c piCompared для "double"
 //!
-//! Пример:
+//! Пример:
 //! \snippet piincludes.cpp compare
 template<typename T>
 inline bool piCompare(const T & a, const T & b, const T & epsilon = std::numeric_limits<T>::epsilon()) {
@@ -718,12 +718,12 @@ inline bool piCompare(const T & a, const T & b, const T & epsilon = std::numeric
 
 //! \brief
 //! \~english Templated function that inverse byte order of value "v"
-//! \~russian Шаблонный метод, меняющий порядок байт в переменной "v"
+//! \~russian Шаблонный метод, меняющий порядок байт в переменной "v"
 template<typename T> inline void piLetobe(T * v) {piLetobe(v, sizeof(T));}
 
 //! \brief
 //! \~english Templated function that returns "v" with inversed byte order
-//! \~russian Шаблонный метод, возвращающий переменную "v" с измененным порядком байт
+//! \~russian Шаблонный метод, возвращающий переменную "v" с измененным порядком байт
 //! \details
 //! \~english
 //! This function used to convert values between little and big endian \n
@@ -736,14 +736,14 @@ template<typename T> inline void piLetobe(T * v) {piLetobe(v, sizeof(T));}
 //! Example:
 //! \snippet piincludes.cpp letobe
 //! \~russian
-//! Этот метод используется для изменения порядка байт между little и big endian
-//! Есть несколько макросов:
-//! - \c piLetobes для "ushort"
-//! - \c piLetobei для "uint"
-//! - \c piLetobel для "ulong"
-//! - \c piLetobell для "ullong"
+//! Этот метод используется для изменения порядка байт между little и big endian
+//! Есть несколько макросов:
+//! - \c piLetobes для "ushort"
+//! - \c piLetobei для "uint"
+//! - \c piLetobel для "ulong"
+//! - \c piLetobell для "ullong"
 //!
-//! Пример:
+//! Пример:
 //! \snippet piincludes.cpp letobe
 template<typename T> inline T piLetobe(const T & v) {T tv(v); piLetobe(&tv, sizeof(T)); return tv;}
 
@@ -763,7 +763,7 @@ template<> inline float piLetobe(const float & v) {
 
 //! \brief
 //! \~english Generic hash function, implements murmur3/32 algorithm
-//! \~russian Хэш-функция общего назначения, по алгоритму murmur3/32
+//! \~russian Хэш-функция общего назначения, по алгоритму murmur3/32
 inline uint piHashData(const uchar * data, uint len, uint seed = 0) {
 	if (!data || len <= 0) return 0u;
 	uint h = seed;