remove md files

- Add operator[], element(), and at() overloads for Index struct
- Add isValid() and isNotValid() methods to Index
- Add default initialization to -1 (invalid state)
- Add parameterized constructor Index(row, col)
- Add tests for new functionality

.gitignore

@@ -6,3 +6,5 @@ CMakeLists.txt.user*
 /include
 /release
 /build*
+/AGENTS.md
+/plans

CMakeLists.txt

@@ -5,8 +5,8 @@ if (POLICY CMP0177)
 endif()
 project(PIP)
 set(PIP_MAJOR    5)
-set(PIP_MINOR    5)
-set(PIP_REVISION 2)
+set(PIP_MINOR    6)
+set(PIP_REVISION 0)
 set(PIP_SUFFIX   )
 set(PIP_COMPANY  SHS)
 set(PIP_DOMAIN   org.SHS)
@@ -221,17 +221,10 @@ if (TESTS)
 	add_subdirectory(tests)
 endif()
 
-if(PIP_MICRO)
-	add_definitions(-DMICRO_PIP)
-	set(ICU OFF)
-	set(LOCAL ON)
-endif()
 if(PIP_FREERTOS)
 	add_definitions(-DPIP_FREERTOS)
-endif()
-if(DEFINED PICO_BOARD)
-	add_definitions(-DPICO_SDK)
-	message(STATUS "Building PIP for Pi Pico SDK ${PICO_SDK_VERSION_STRING}")
+	set(ICU OFF)
+	set(LOCAL ON)
 endif()
 
 # Check Bessel functions
@@ -336,7 +329,7 @@ if ((NOT DEFINED SHSTKPROJECT) AND (DEFINED ANDROID_PLATFORM))
 	#message("${ANDROID_NDK}/sysroot/usr/include")
 endif()
 
-if(NOT PIP_MICRO)
+if(NOT PIP_FREERTOS)
 	if(WIN32)
 		if(${C_COMPILER} STREQUAL "cl.exe")
 		else()
@@ -357,7 +350,7 @@ if(NOT PIP_MICRO)
 	endif()
 endif()
 set(PIP_LIBS)
-if(PIP_MICRO)
+if(PIP_FREERTOS)
 	set(PIP_LIBS ${LIBS_MAIN})
 else()
 	foreach(LIB_ ${LIBS_MAIN})
@@ -371,11 +364,11 @@ if(WIN32)
 	endif()
 else()
 	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC")
+	if(DEFINED ENV{QNX_HOST} OR PIP_FREERTOS)
+		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ftemplate-depth-32")
+	endif()
 endif()
 set(CMAKE_C_FLAGS "${CMAKE_CXX_FLAGS}")
-if(DEFINED ENV{QNX_HOST} OR PIP_MICRO)
-	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ftemplate-depth-32")
-endif()
 
 set(PCRE2_BUILD_PCRE2_8   OFF)
 set(PCRE2_BUILD_PCRE2_16  ON )
@@ -413,7 +406,7 @@ endif()
 
 
 if (NOT CROSSTOOLS)
-	if (NOT PIP_MICRO)
+	if (NOT PIP_FREERTOS)
 
 		if (PIP_BUILD_CONSOLE)
 			pip_module(console "" "PIP console support" "" "" "")
@@ -631,7 +624,7 @@ string(REPLACE ";" "," PIP_EXPORTS_STR "${PIP_EXPORTS}")
 target_compile_definitions(pip PRIVATE "PICODE_DEFINES=\"${PIP_EXPORTS_STR}\"")
 
 
-if(NOT PIP_MICRO)
+if(NOT PIP_FREERTOS)
 
 # Auxiliary
 	if (NOT CROSSTOOLS)
@@ -708,7 +701,7 @@ if(NOT LOCAL)
 		install(TARGETS ${PIP_MODULES} DESTINATION ${CMAKE_INSTALL_PREFIX}/lib)
 	endif()
 else()
-	if(NOT PIP_MICRO)
+	if(NOT PIP_FREERTOS)
 		if(WIN32)
 			install(TARGETS ${PIP_MODULES} RUNTIME DESTINATION bin)
 			install(TARGETS ${PIP_MODULES} ARCHIVE DESTINATION lib)
@@ -736,7 +729,7 @@ endif()
 #
 # Build Documentation
 #
-if ((NOT PIP_MICRO) AND (NOT CROSSTOOLS))
+if ((NOT PIP_FREERTOS) AND (NOT CROSSTOOLS))
 	include(PIPDocumentation)
 	find_package(Doxygen)
 	if(DOXYGEN_FOUND)
@@ -805,7 +798,7 @@ message(" Type   : ${CMAKE_BUILD_TYPE}")
 if (NOT LOCAL)
 	message(" Install: \"${CMAKE_INSTALL_PREFIX}\"")
 else()
-	if(NOT PIP_MICRO)
+	if(NOT PIP_FREERTOS)
 		message(" Install: local \"bin\", \"lib\" and \"include\"")
 	endif()
 endif()
@@ -838,7 +831,7 @@ message(" Utilites:")
 foreach(_util ${PIP_UTILS_LIST})
 	message("  * ${_util}")
 endforeach()
-if(NOT PIP_MICRO)
+if(NOT PIP_FREERTOS)
 	message("")
 	message(" Using libraries:")
 	foreach(LIB_ ${LIBS_STATUS})

README.md

@@ -40,3 +40,118 @@ You should add ${<out_var>} to your target.
 [🇷🇺 Онлайн документация](https://shstk.ru/pip/html/ru/index.html)
 
 [🇷🇺 Qt-help](https://shstk.ru/pip/pip_ru.qch)
+
+## Основные опции сборки
+
+### Стандартные опции (option())
+| Опция | Описание | По умолчанию |
+|-------|----------|--------------|
+| `ICU` | ICU support для конвертации кодовых страниц | ON (кроме Win/Android/Apple) |
+| `STD_IOSTREAM` | Поддержка std::iostream операторов | OFF |
+| `INTROSPECTION` | Сборка с интроспекцией | OFF |
+| `TESTS` | Сборка тестов | OFF |
+| `COVERAGE` | Сборка с информацией о покрытии | OFF |
+| `PIP_FFTW_F` | Поддержка FFTW для float | ON |
+| `PIP_FFTW_L` | Поддержка FFTW для long double | ON |
+| `PIP_FFTW_Q` | Поддержка FFTW для quad double | OFF |
+
+### Опции модулей (PIP_BUILD_*)
+| Опция | Модуль |
+|-------|--------|
+| `PIP_BUILD_CONSOLE` | console |
+| `PIP_BUILD_CRYPT` | crypt (требует libsodium) |
+| `PIP_BUILD_COMPRESS` | compress (требует zlib) |
+| `PIP_BUILD_USB` | usb |
+| `PIP_BUILD_FFTW` | fftw |
+| `PIP_BUILD_OPENCL` | opencl |
+| `PIP_BUILD_IO_UTILS` | io_utils |
+| `PIP_BUILD_CLIENT_SERVER` | client_server |
+| `PIP_BUILD_CLOUD` | cloud |
+| `PIP_BUILD_LUA` | lua |
+| `PIP_BUILD_HTTP_CLIENT` | http_client (требует libcurl) |
+| `PIP_BUILD_HTTP_SERVER` | http_server (требует libmicrohttpd) |
+
+### Дополнительные переменные
+| Переменная | Описание |
+|------------|----------|
+| `PIP_BUILD_DEBUG` | Сборка debug версии |
+| `PIP_FREERTOS` | Режим сборки для FreeRTOS |
+| `CROSSTOOLS` | Собрать инструменты кросс-сборки под хостовую систему (pip_cmg, pip_rc, ...) |
+| `LOCAL` | Локальная установка (bin/lib/include) |
+| `PIP_CONTAINERS_MIN_ALLOC` | Переопределить минимальный размер аллокации контейнеров |
+| `PIP_CONTAINERS_MAX_POT_ALLOC` | Переопределить максимальный размер дополнительной аллокации (поддерживает X_KiB, X_MiB) |
+
+### Примеры использования
+```bash
+# Базовая сборка с тестами
+cmake -B build -DTESTS=ON
+
+# Сборка с покрытием и ICU
+cmake -B build -DTESTS=ON -DCOVERAGE=ON -DICU=ON
+
+# Отключение отдельных модулей
+cmake -B build -DPIP_BUILD_CRYPT=OFF -DPIP_BUILD_OPENCL=OFF
+
+# Переопределение параметров контейнеров
+cmake -B build -DPIP_CONTAINERS_MIN_ALLOC=64
+
+# Локальная установка
+cmake -B build -DLOCAL=ON
+```
+
+## PIP Dependencies
+
+### Встроенные (included in 3rd/)
+
+| Библиотека | Назначение | Модуль PIP |
+|------------|------------|------------|
+| **PCRE2** | Регулярные выражения | main (internal) |
+| **BLAKE2** | Хеширование | main (internal) |
+| **SipHash** | Хеширование | main (internal) |
+| **Lua** | Lua scripting | lua |
+| **LuaBridge** | Lua bindings | lua |
+
+### Внешние (системные)
+
+| Библиотека | Опция | Модуль PIP |
+|------------|-------|------------|
+| **ICU** | `-DICU=ON` | main (string conversion) |
+| **zlib** | `PIP_BUILD_COMPRESS` | compress |
+| **libsodium** | `PIP_BUILD_CRYPT` | crypt, io_utils, cloud |
+| **libusb** | `PIP_BUILD_USB` | usb |
+| **FFTW3** (+ threads) | `PIP_BUILD_FFTW` | fftw |
+| **OpenCL** | `PIP_BUILD_OPENCL` | opencl |
+| **libmicrohttpd** | `PIP_BUILD_HTTP_SERVER` | http_server |
+| **libcurl** | `PIP_BUILD_HTTP_CLIENT` | http_client |
+
+### Опциональные (тесты/документация)
+
+| Инструмент | Назначение |
+|------------|------------|
+| **Google Test** | Тестирование (fetched automatically) |
+| **Doxygen** | Генерация документации |
+
+
+### Схема зависимостей модулей
+
+```
+main (core)
+├── PCRE2 (встроен)
+├── BLAKE2 (встроен)
+├── SipHash (встроен)
+└── ICU (опционально)
+
+console     → main
+compress    → zlib
+crypt       → libsodium
+usb         → libusb
+fftw        → FFTW3
+opencl      → OpenCL
+io_utils    → [crypt, если доступен]
+client_server → io_utils
+cloud       → io_utils, crypt
+lua         → Lua (встроен), LuaBridge (встроен)
+http_server → libmicrohttpd
+http_client → libcurl
+```
+

cmake/FindPIP.cmake

@@ -71,7 +71,7 @@ if (NOT BUILDING_PIP)
 			find_library(PTHREAD_LIBRARY pthread)
 			find_library(UTIL_LIBRARY util)
 			set(_PIP_ADD_LIBS_ ${PTHREAD_LIBRARY} ${UTIL_LIBRARY})
-			if((NOT DEFINED ENV{QNX_HOST}) AND (NOT APPLE) AND (NOT PIP_MICRO))
+			if((NOT DEFINED ENV{QNX_HOST}) AND (NOT APPLE) AND (NOT PIP_FREERTOS))
 				find_library(RT_LIBRARY rt)
 				list(APPEND _PIP_ADD_LIBS_ ${RT_LIBRARY})
 			endif()

esp-pip/CMakeLists.txt

@@ -17,7 +17,6 @@ list(APPEND COMPONENT_ADD_INCLUDEDIRS "../libs/main/thread")
 set(COMPONENT_PRIV_REQUIRES pthread lwip freertos vfs spi_flash libsodium)
 register_component()
 set(PIP_FREERTOS ON)
-set(PIP_MICRO ON)
 set(LIB OFF)
 set(INCLUDE_DIRS ${IDF_INCLUDE_DIRECTORIES})
 list(APPEND INCLUDE_DIRS $ENV{IDF_PATH}/components/newlib/platform_include)

libs/http_client/pihttpclient.cpp

@@ -59,7 +59,7 @@ bool PIHTTPClient::init() {
 	if (is_cancel) return false;
 	CurlThreadPool::instance();
 	if (!PRIVATE->init()) return false;
-	auto ait = request.arguments().makeIterator();
+	auto ait = request.queryArguments().makeIterator();
 	while (ait.next()) {
 		if (!url.contains('?'))
 			url.append('?');

libs/main/application/pisystemmonitor.cpp

@@ -113,7 +113,7 @@ bool PISystemMonitor::startOnProcess(int pID, PISystemTime interval) {
 	}
 #	endif
 #  else
-	PRIVATE->hProc      = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, pID_);
+	PRIVATE->hProc = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, pID_);
 	if (PRIVATE->hProc == 0) {
 		piCoutObj << "Can`t open process with ID = %1, %2!"_tr("PISystemMonitor").arg(pID_).arg(errorString());
 		return false;
@@ -178,9 +178,6 @@ PISystemTime uint64toST(uint64_t v) {
 void PISystemMonitor::run() {
 	cur_tm.clear();
 	tbid.clear();
-	ProcessStats tstat;
-	tstat.ID = pID_;
-#ifndef PIP_NO_THREADS
 	__PIThreadCollection * pitc = __PIThreadCollection::instance();
 	pitc->lock();
 	PIVector<PIThread *> tv = pitc->threads();
@@ -188,14 +185,16 @@ void PISystemMonitor::run() {
 		if (t->isPIObject()) tbid[t->tid()] = t->name();
 	pitc->unlock();
 	// piCout << tbid.keys().toType<uint>();
-#  ifdef FREERTOS
+	ProcessStats tstat;
+	tstat.ID = pID_;
+#ifdef MICRO_PIP
 	for (auto * t: tv)
 		if (t->isPIObject()) gatherThread(t->tid());
-#  else // FREERTOS
-#	ifndef WINDOWS
+#else
+#  ifndef WINDOWS
 	double delay_ms = delay_.toMilliseconds();
 	tbid[pID_]      = "main";
-#	  ifdef MAC_OS
+#	ifdef MAC_OS
 	rusage_info_current ru;
 	proc_pid_rusage(pID_, RUSAGE_INFO_CURRENT, (rusage_info_t *)&ru);
 	// piCout << PISystemTime(((uint*)&(ru.ri_user_time))[1], ((uint*)&(ru.ri_user_time))[0]);
@@ -211,7 +210,7 @@ void PISystemMonitor::run() {
 	tstat.cpu_load_user   = 100.f * (PRIVATE->cpu_u_cur - PRIVATE->cpu_u_prev).toMilliseconds() / delay_ms;
 	cycle                 = 0;
 	// piCout << (PRIVATE->cpu_u_cur - PRIVATE->cpu_u_prev).toMilliseconds() / delay_ms;
-#	  else  // MAC_OS
+#	else
 	PRIVATE->file.seekToBegin();
 	PIString str = PIString::fromAscii(PRIVATE->file.readAll());
 	int si = str.find('(') + 1, fi = 0, cc = 1;
@@ -265,8 +264,8 @@ void PISystemMonitor::run() {
 		if (i.flags[PIFile::FileInfo::Dot] || i.flags[PIFile::FileInfo::DotDot]) continue;
 		gatherThread(i.name().toInt());
 	}
-#	  endif // MAC_OS
-#	else    // WINDOWS
+#	endif
+#  else
 	if (GetProcessMemoryInfo(PRIVATE->hProc, &PRIVATE->mem_cnt, sizeof(PRIVATE->mem_cnt)) != 0) {
 		tstat.physical_memsize = PRIVATE->mem_cnt.WorkingSetSize;
 	}
@@ -316,9 +315,8 @@ void PISystemMonitor::run() {
 		tstat.cpu_load_user   = 0.f;
 	}
 	PRIVATE->tm.reset();
-#	endif   // WINDOWS
-#  endif     // FREERTOS
-#endif       // PIP_NO_THREADS
+#  endif
+#endif
 
 	tstat.cpu_load_system = piClampf(tstat.cpu_load_system, 0.f, 100.f);
 	tstat.cpu_load_user   = piClampf(tstat.cpu_load_user, 0.f, 100.f);
@@ -354,7 +352,7 @@ void PISystemMonitor::gatherThread(llong id) {
 #ifdef MICRO_PIP
 	ts.name = tbid.value(id, "<PIThread>");
 #else
-	ts.name  = tbid.value(id, "<non-PIThread>");
+	ts.name = tbid.value(id, "<non-PIThread>");
 #  ifndef WINDOWS
 	PIFile f(PRIVATE->proc_dir + "task/" + PIString::fromNumber(id) + "/stat");
 	// piCout << f.path();

libs/main/console/pikbdlistener.cpp

@@ -18,11 +18,9 @@
 */
 #include "pikbdlistener.h"
 
-#ifndef MICRO_PIP
-
-#  include "piincludes_p.h"
-#  include "piliterals.h"
-#  include "piwaitevent_p.h"
+#include "piincludes_p.h"
+#include "piliterals.h"
+#include "piwaitevent_p.h"
 // clang-format off
 #ifndef WINDOWS
 #  include <termios.h>
@@ -51,7 +49,7 @@ bool PIKbdListener::exiting;
 PIKbdListener * PIKbdListener::_object = 0;
 
 
-#  ifndef WINDOWS
+#ifndef WINDOWS
 // unix
 const PIKbdListener::EscSeq PIKbdListener::esc_seq[] = {
 	{"OA",   PIKbdListener::UpArrow,    0, 0,        1},
@@ -132,22 +130,22 @@ void setupTerminal(bool on) {
 	printf(on ? "h" : "l");
 	fflush(0);
 }
-#  endif
+#endif
 
 
 PRIVATE_DEFINITION_START(PIKbdListener)
-#  ifdef WINDOWS
+#ifdef WINDOWS
 	void *hIn, *hOut;
 	DWORD smode, tmode;
 	CONSOLE_SCREEN_BUFFER_INFO sbi;
-#  else
+#else
 	struct termios sterm, tterm;
-#  endif
-#  ifdef WINDOWS
+#endif
+#ifdef WINDOWS
 	DWORD
-#  else
+#else
 	int
-#  endif
+#endif
 	ret;
 	PIWaitEvent event;
 PRIVATE_DEFINITION_END(PIKbdListener)
@@ -156,13 +154,13 @@ PRIVATE_DEFINITION_END(PIKbdListener)
 PIKbdListener::PIKbdListener(KBFunc slot, void * _d, bool startNow): PIThread() {
 	setName("keyboard_listener"_a);
 	_object = this;
-#  ifdef WINDOWS
+#ifdef WINDOWS
 	PRIVATE->hIn  = GetStdHandle(STD_INPUT_HANDLE);
 	PRIVATE->hOut = GetStdHandle(STD_OUTPUT_HANDLE);
 	GetConsoleMode(PRIVATE->hIn, &PRIVATE->smode);
-#  else
+#else
 	tcgetattr(0, &PRIVATE->sterm);
-#  endif
+#endif
 	ret_func     = slot;
 	kbddata_     = _d;
 	dbl_interval = 400;
@@ -180,10 +178,10 @@ PIKbdListener::~PIKbdListener() {
 
 
 void PIKbdListener::begin() {
-#  ifdef WINDOWS
+#ifdef WINDOWS
 	GetConsoleMode(PRIVATE->hIn, &PRIVATE->tmode);
 	SetConsoleMode(PRIVATE->hIn, ENABLE_PROCESSED_INPUT | ENABLE_MOUSE_INPUT | ENABLE_EXTENDED_FLAGS);
-#  else
+#else
 	struct termios term;
 	tcgetattr(0, &term);
 	term.c_lflag &= ~(ECHO | ICANON);
@@ -191,11 +189,11 @@ void PIKbdListener::begin() {
 	PRIVATE->tterm = term;
 	tcsetattr(0, TCSANOW, &term);
 	setupTerminal(true);
-#  endif
+#endif
 }
 
 
-#  ifdef WINDOWS
+#ifdef WINDOWS
 PIKbdListener::KeyModifiers getModifiers(DWORD v, bool * shift = 0) {
 	PIKbdListener::KeyModifiers ret;
 	bool ctrl = v & (LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED);
@@ -216,7 +214,7 @@ PIKbdListener::MouseButtons getButtons(DWORD v) {
 	if (v & FROM_LEFT_2ND_BUTTON_PRESSED) ret |= PIKbdListener::MouseMiddle;
 	return ret;
 }
-#  endif
+#endif
 
 
 void PIKbdListener::readKeyboard() {
@@ -224,7 +222,7 @@ void PIKbdListener::readKeyboard() {
 	ke.modifiers = 0;
 	char rc[8];
 	piZeroMemory(rc, 8);
-#  ifdef WINDOWS
+#ifdef WINDOWS
 	INPUT_RECORD ir;
 	ReadConsoleInput(PRIVATE->hIn, &ir, 1, &(PRIVATE->ret));
 	switch (ir.EventType) {
@@ -408,7 +406,7 @@ void PIKbdListener::readKeyboard() {
 	} break;
 	default: piMSleep(10); return;
 	}
-#  else
+#else
 	tcsetattr(0, TCSANOW, &PRIVATE->tterm);
 	if (!PRIVATE->event.wait(0)) return;
 	PRIVATE->ret = read(0, rc, 8);
@@ -535,7 +533,7 @@ void PIKbdListener::readKeyboard() {
 		cout << endl;*/
 	}
 	if (ke.key == 0 && PRIVATE->ret > 1) ke.key = PIChar::fromSystem(rc).unicode16Code();
-#  endif
+#endif
 	if ((rc[0] == '\n' || rc[0] == '\r') && PRIVATE->ret == 1) ke.key = Return;
 	if (exit_enabled && ke.key == exit_key) {
 		PIKbdListener::exiting = true;
@@ -562,32 +560,30 @@ bool PIKbdListener::stopAndWait(PISystemTime timeout) {
 
 void PIKbdListener::end() {
 	// cout << "list end" << endl;
-#  ifdef WINDOWS
+#ifdef WINDOWS
 	SetConsoleMode(PRIVATE->hIn, PRIVATE->smode);
-#  else
+#else
 	tcsetattr(0, TCSANOW, &PRIVATE->sterm);
 	setupTerminal(false);
-#  endif
+#endif
 }
 
 
 void PIKbdListener::setActive(bool yes) {
 	is_active = yes;
 	if (is_active) {
-#  ifdef WINDOWS
+#ifdef WINDOWS
 		SetConsoleMode(PRIVATE->hIn, PRIVATE->tmode);
-#  else
+#else
 		tcsetattr(0, TCSANOW, &PRIVATE->tterm);
 		setupTerminal(true);
-#  endif
+#endif
 	} else {
-#  ifdef WINDOWS
+#ifdef WINDOWS
 		SetConsoleMode(PRIVATE->hIn, PRIVATE->smode);
-#  else
+#else
 		tcsetattr(0, TCSANOW, &PRIVATE->sterm);
 		setupTerminal(false);
-#  endif
+#endif
 	}
 }
-
-#endif // MICRO_PIP

libs/main/console/pikbdlistener.h

@@ -26,19 +26,15 @@
 #ifndef PIKBDLISTENER_H
 #define PIKBDLISTENER_H
 
-#include "pibase.h"
+#include "pithread.h"
+#include "pitime.h"
 
-#ifndef MICRO_PIP
-
-#  include "pithread.h"
-#  include "pitime.h"
-
-#  define WAIT_FOR_EXIT                                                                                                      \
-	  while (!PIKbdListener::exiting)                                                                                        \
-		  piMSleep(PIP_MIN_MSLEEP * 5);                                                                                      \
-	  if (PIKbdListener::instance()) {                                                                                       \
-		  if (!PIKbdListener::instance()->stopAndWait(PISystemTime::fromSeconds(1))) PIKbdListener::instance()->terminate(); \
-	  }
+#define WAIT_FOR_EXIT                                                                                                      \
+	while (!PIKbdListener::exiting)                                                                                        \
+		piMSleep(PIP_MIN_MSLEEP * 5);                                                                                      \
+	if (PIKbdListener::instance()) {                                                                                       \
+		if (!PIKbdListener::instance()->stopAndWait(PISystemTime::fromSeconds(1))) PIKbdListener::instance()->terminate(); \
+	}
 
 
 class PIP_EXPORT PIKbdListener: public PIThread {
@@ -235,7 +231,7 @@ private:
 	void run() override { readKeyboard(); }
 	void end() override;
 
-#  ifndef WINDOWS
+#ifndef WINDOWS
 	struct PIP_EXPORT EscSeq {
 		const char * seq;
 		int key;
@@ -255,7 +251,7 @@ private:
 	};
 
 	static const EscSeq esc_seq[];
-#  endif
+#endif
 
 	PRIVATE_DECLARATION(PIP_EXPORT)
 	KBFunc ret_func;
@@ -309,5 +305,4 @@ REGISTER_PIVARIANTSIMPLE(PIKbdListener::KeyEvent)
 REGISTER_PIVARIANTSIMPLE(PIKbdListener::MouseEvent)
 REGISTER_PIVARIANTSIMPLE(PIKbdListener::WheelEvent)
 
-#endif // MICRO_PIP
 #endif // PIKBDLISTENER_H

libs/main/containers/pivector.h

@@ -835,8 +835,8 @@ public:
 	//! piCout << v.contains({1,4}); // true
 	//! piCout << v.contains({1,5}); // false
 	//! \endcode
-	//! \~\sa \a every(), \a any(), \a entries(), \a forEach()
-	inline bool contains(const PIVector<T> & v, ssize_t start = 0) const {
+	//! \~\sa \a every(), \a any(), \a entries(), \a forEach(), \a contains()
+	inline bool containsAll(const PIVector<T> & v, ssize_t start = 0) const {
 		if (start < 0) {
 			start = piv_size + start;
 			if (start < 0) start = 0;
@@ -854,6 +854,24 @@ public:
 		return true;
 	}
 
+	//! \~english Tests if any element of `v` exists in the array.
+	//! \~russian Проверяет наличие хотя бы одного из элементов `v` в массиве.
+	//! \~\sa \a containsAll(), \a contains()
+	inline bool containsAny(const PIVector<T> & v, ssize_t start = 0) const {
+		if (start < 0) {
+			start = piv_size + start;
+			if (start < 0) start = 0;
+		}
+		for (const T & e: v) {
+			for (size_t i = start; i < piv_size; ++i) {
+				if (e == piv_data[i]) {
+					return true;
+				}
+			}
+		}
+		return false;
+	}
+
 	//! \~english Count elements equal `e` in the array.
 	//! \~russian Подсчитывает количество элементов, совпадающих с элементом `e` в массиве.
 	//! \~\details
@@ -1303,14 +1321,16 @@ public:
 	//! piCout << v; // {1, 3, 7, 5}
 	//! \endcode
 	//! \~\sa \a append(), \a prepend(), \a remove()
-	inline PIVector<T> & insert(size_t index, const T & e = T()) {
-		alloc(piv_size + 1);
-		if (index < piv_size - 1) {
-			const size_t os = piv_size - index - 1;
-			memmove(reinterpret_cast<void *>(piv_data + index + 1), reinterpret_cast<const void *>(piv_data + index), os * sizeof(T));
+	inline PIVector<T> & insert(size_t index, const T & e = T(), size_t count = 1) {
+		alloc(piv_size + count);
+		if (index < piv_size - count) {
+			const size_t os = piv_size - index - count;
+			memmove(reinterpret_cast<void *>(piv_data + index + count), reinterpret_cast<const void *>(piv_data + index), os * sizeof(T));
+		}
+		PIINTROSPECTION_CONTAINER_USED(T, count)
+		for (size_t i = 0; i < count; ++i) {
+			elementNew(piv_data + index + i, e);
 		}
-		PIINTROSPECTION_CONTAINER_USED(T, 1)
-		elementNew(piv_data + index, e);
 		return *this;
 	}
 
@@ -1349,8 +1369,8 @@ public:
 		alloc(piv_size + v.piv_size);
 		if (os > 0) {
 			memmove(reinterpret_cast<void *>(piv_data + index + v.piv_size),
-					reinterpret_cast<const void *>(piv_data + index),
-					os * sizeof(T));
+			        reinterpret_cast<const void *>(piv_data + index),
+			        os * sizeof(T));
 		}
 		newT(piv_data + index, v.piv_data, v.piv_size);
 		return *this;
@@ -1372,8 +1392,8 @@ public:
 		alloc(piv_size + init_list.size());
 		if (os > 0) {
 			memmove(reinterpret_cast<void *>(piv_data + index + init_list.size()),
-					reinterpret_cast<const void *>(piv_data + index),
-					os * sizeof(T));
+			        reinterpret_cast<const void *>(piv_data + index),
+			        os * sizeof(T));
 		}
 		newT(piv_data + index, init_list.begin(), init_list.size());
 		return *this;

libs/main/containers/pivector2d.h

@@ -1,7 +1,7 @@
 /*! \file pivector2d.h
  * \brief 2D wrapper around PIVector
  *
- * This file declares PIVector
+ * This file declares PIVector2D
  */
 /*
     PIP - Platform Independent Primitives
@@ -27,29 +27,111 @@
 
 #include "pivector.h"
 
-/*! \brief 2D array,
- * \details This class used to store 2D array of any type elements as plain vector.
- * You can read/write any element via operators [][], first dimension - row, second - column.
- * The first dimension is Row, and you can operate with Row as PIVector<T>: modify any element, assign to another Row and etc.
- * You can't add values to array, but you can modify any elements or create another PIVector2D.
- * PIVector2D has constructors from PIVector<T> and PIVector<PIVector<T> >
- */
+//! \addtogroup Containers
+//! \{
+//! \class PIVector2D
+//! \brief
+//! \~english 2D array container.
+//! \~russian Двумерный контейнер-массив.
+//! \details
+//! \~english
+//! This class is used to store a 2D array of elements of any type as a single continuous block of memory (a plain PIVector).
+//! Elements can be accessed using the `[][]` operators, where the first index is the row and the second is the column.
+//! Rows can be manipulated as \a PIVector objects, allowing modification of individual elements or assignment of entire rows.
+//! You cannot directly add or remove elements to change the dimensions of the array after construction
+//! (use \a resize(), \a addRow(), \a removeRow(), \a removeColumn() instead), but you can modify the values of existing elements.
+//! \~russian
+//! Этот класс используется для хранения двумерного массива элементов любого типа в виде единого непрерывного блока памяти (обычного
+//! \a PIVector). Доступ к элементам осуществляется с помощью операторов `[][]`, где первый индекс — это строка, а второй — столбец. Со
+//! строками можно работать как с объектами \a PIVector, что позволяет изменять отдельные элементы или присваивать целые строки. Нельзя
+//! напрямую добавлять или удалять элементы, чтобы изменить размеры массива после создания (используйте \a resize(), \a addRow(), \a
+//! removeRow(), \a removeColumn() для этого), но можно изменять значения существующих элементов.
+
 
 template<typename T>
 class PIVector2D {
 public:
+	//! \brief
+	//! \~english Index structure for 2D array elements (row, column).
+	//! \~russian Структура индекса для элементов двумерного массива (строка, столбец).
+	struct Index {
+		//! \~english Row index in the 2D array.
+		//! \~russian Индекс строки в двумерном массиве.
+		ssize_t row    = -1;
+		//! \~english Column index in the 2D array.
+		//! \~russian Индекс столбца в двумерном массиве.
+		ssize_t col    = -1;
+
+		//! \~english Default constructor. Initializes row and col to -1 (invalid index).
+		//! \~russian Конструктор по умолчанию. Инициализирует row и col значениями -1 (некорректный индекс).
+		inline Index() = default;
+		//! \~english Constructs an Index with the given row and column values.
+		//! \~russian Создаёт Index с заданными значениями строки и столбца.
+		inline Index(ssize_t r, ssize_t c): row(r), col(c) {}
+
+		//! \~english Checks if the index is valid (both row and column are non-negative).
+		//! \~russian Проверяет, является ли индекс корректным (строка и столбец неотрицательны).
+		//! \~\sa isNotValid()
+		inline bool isValid() const { return row >= 0 && col >= 0; }
+
+		//! \~english Checks if the index is invalid (either row or column is negative).
+		//! \~russian Проверяет, является ли индекс некорректным (строка или столбец отрицательны).
+		//! \~\sa isValid()
+		inline bool isNotValid() const { return !isValid(); }
+	};
+
+	//! \~english Constructs an empty 2D array. No memory is allocated.
+	//! \~russian Создаёт пустой двумерный массив. Память не выделяется.
+	//! \details
+	//! \~english After this constructor, \a rows() and \a cols() return 0, and \a isEmpty() returns true.
+	//! \~russian После этого конструктора \a rows() и \a cols() возвращают 0, а \a isEmpty() возвращает true.
+	//! \~\sa PIVector::PIVector()
 	inline PIVector2D() { rows_ = cols_ = 0; }
 
+	//! \~english Constructs a 2D array with the given dimensions, filled with copies of `f`.
+	//! \~russian Создаёт двумерный массив заданного размера, заполненный копиями `f`.
+	//! \details
+	//! \~english The underlying storage is a single contiguous block of memory of size `rows * cols`.
+	//! All elements are initialized with the value `f`.
+	//! \~russian Внутреннее хранилище представляет собой единый непрерывный блок памяти размером `rows * cols`.
+	//! Все элементы инициализируются значением `f`.
+	//! \~\sa PIVector::PIVector(size_t, const T&)
 	inline PIVector2D(size_t rows, size_t cols, const T & f = T()) {
 		rows_ = rows;
 		cols_ = cols;
 		mat.resize(rows * cols, f);
 	}
 
+	//! \~english Constructs a 2D array from an existing 1D vector, reshaping it.
+	//! \~russian Создаёт двумерный массив из существующего одномерного вектора, изменяя его форму.
+	//! \details
+	//! \~english The constructor copies the data from `v` into the internal flat vector.
+	//! If `v` is larger than `rows * cols`, the excess elements are ignored (the vector is truncated).
+	//! If `v` is smaller, other values filled whith default cunstructor T()
+	//! \~russian Конструктор копирует данные из `v` во внутренний плоский вектор.
+	//! Если `v` больше, чем `rows * cols`, лишние элементы игнорируются (вектор обрезается).
+	//! Если `v` меньше, остальные значения будут заполнены из конструктора по умолчанию T()
+	//! \~\sa PIVector::PIVector(const PIVector&), reshape()
 	inline PIVector2D(size_t rows, size_t cols, const PIVector<T> & v): rows_(rows), cols_(cols), mat(v) { mat.resize(rows * cols); }
 
+	//! \~english Move constructs a 2D array from an existing 1D vector, reshaping it.
+	//! \~russian Конструктор перемещения из существующего одномерного вектора, изменяя его форму.
+	//! \details
+	//! \~english The data is moved from `v` into the internal flat vector, avoiding a copy.
+	//! After construction, `v` is left in a valid but unspecified state.
+	//! \~russian Данные перемещаются из `v` во внутренний плоский вектор, что позволяет избежать копирования.
+	//! После завершения конструктора `v` остаётся в корректном, но неопределённом состоянии.
+	//! \~\sa PIVector::PIVector(PIVector&&)
 	inline PIVector2D(size_t rows, size_t cols, PIVector<T> && v): rows_(rows), cols_(cols), mat(std::move(v)) { mat.resize(rows * cols); }
 
+	//! \~english Constructs a 2D array from a vector of vectors (jagged array). Assumes all inner vectors have the same size.
+	//! \~russian Создаёт двумерный массив из вектора векторов (рваного массива). Предполагается, что все внутренние векторы имеют
+	//! одинаковый размер.
+	//! \details
+	//! \~english If the input is empty, the constructed array is also empty. Otherwise, the number of columns is taken from the size of the
+	//! first inner vector. All inner vectors are concatenated in the internal flat storage.
+	//! \~russian Если входной массив пуст, создаётся пустой двумерный массив. В противном случае количество столбцов берётся из размера
+	//! первого внутреннего вектора. Все внутренние векторы конкатенируются во внутреннем плоском хранилище. \sa PIVector::append()
 	inline PIVector2D(const PIVector<PIVector<T>> & v) {
 		rows_ = v.size();
 		if (rows_) {
@@ -63,219 +145,858 @@ public:
 		if (mat.isEmpty()) rows_ = cols_ = 0;
 	}
 
+	//! \~english Returns the number of rows in the 2D array.
+	//! \~russian Возвращает количество строк в двумерном массиве.
+	//! \return Number of rows.
+	//! \details
+	//! \~english The result is always non-negative. If the array is empty, returns 0.
+	//! \~russian Результат всегда неотрицательный. Если массив пуст, возвращает 0.
+	//! \~\sa cols(), size(), PIVector::size()
 	inline size_t rows() const { return rows_; }
 
+	//! \~english Returns the number of columns in the 2D array.
+	//! \~russian Возвращает количество столбцов в двумерном массиве.
+	//! \return Number of columns.
+	//! \details
+	//! \~english The result is always non-negative. If the array is empty, returns 0.
+	//! \~russian Результат всегда неотрицательный. Если массив пуст, возвращает 0.
+	//! \~\sa rows(), size(), PIVector::size()
 	inline size_t cols() const { return cols_; }
 
+	//! \~english Returns the total number of elements (`rows * cols`).
+	//! \~russian Возвращает общее количество элементов (`строки * столбцы`).
+	//! \return Total number of elements.
+	//! \details
+	//! \~english This is equivalent to the size of the underlying flat vector.
+	//! \~russian Это эквивалентно размеру внутреннего плоского вектора.
+	//! \~\sa rows(), cols(), PIVector::size()
 	inline size_t size() const { return mat.size(); }
 
+	//! \~english Returns the total number of elements as a signed value.
+	//! \~russian Возвращает общее количество элементов в виде знакового числа.
+	//! \return Signed size.
+	//! \~\sa size(), PIVector::size_s()
 	inline ssize_t size_s() const { return mat.size_s(); }
 
+	//! \~english Returns the total number of elements (same as \a size()).
+	//! \~russian Возвращает общее количество элементов (то же, что и \a size()).
+	//! \return Total number of elements.
+	//! \~\sa size(), PIVector::length()
 	inline size_t length() const { return mat.length(); }
 
+	//! \~english Returns the number of elements that the underlying container has currently allocated space for.
+	//! \~russian Возвращает количество элементов, для которого сейчас выделена память во внутреннем контейнере.
+	//! \return Capacity of the flat vector.
+	//! \details
+	//! \~english This value may be larger than \a size(). It indicates how many elements can be added before a reallocation is needed.
+	//! \~russian Это значение может быть больше, чем \a size(). Оно показывает, сколько элементов можно добавить до того, как потребуется
+	//! перераспределение памяти. \sa reserve(), PIVector::capacity()
 	inline size_t capacity() const { return mat.capacity(); }
 
+	//! \~english Checks if the array has no elements.
+	//! \~russian Проверяет, пуст ли массив.
+	//! \return \c true if the array is empty, \c false otherwise.
+	//! \details
+	//! \~english An empty array has both rows and columns equal to 0.
+	//! \~russian Пустой массив имеет и строки, и столбцы равные 0.
+	//! \~\sa isNotEmpty(), PIVector::isEmpty()
 	inline bool isEmpty() const { return mat.isEmpty(); }
 
+	//! \~english Checks if the array has at least one element.
+	//! \~russian Проверяет, не пуст ли массив.
+	//! \return \c true if the array is not empty, \c false otherwise.
+	//! \~\sa isEmpty(), PIVector::isNotEmpty()
 	inline bool isNotEmpty() const { return mat.isNotEmpty(); }
 
-	class Row {
-		friend class PIVector2D<T>;
+	class RowConst;
+	class ColConst;
+	class Row;
+	class Col;
 
-	private:
-		inline Row(PIVector2D<T> * p, size_t row): p_(&(p->mat)) {
-			st_ = p->cols_ * row;
-			sz_ = p->cols_;
-		}
-		PIVector<T> * p_;
-		size_t st_, sz_;
-
-	public:
-		inline size_t size() const { return sz_; }
-		inline T & operator[](size_t index) { return (*p_)[st_ + index]; }
-		inline const T & operator[](size_t index) const { return (*p_)[st_ + index]; }
-		inline T * data(size_t index = 0) { return p_->data(st_ + index); }
-		inline const T * data(size_t index = 0) const { return p_->data(st_ + index); }
-		inline Row & operator=(const Row & other) {
-			if (p_ == other.p_ && st_ == other.st_) return *this;
-			const size_t sz = piMin<size_t>(sz_, other.sz_);
-			p_->_copyRaw(p_->data(st_), other.data(), sz);
-			return *this;
-		}
-		inline Row & operator=(const PIVector<T> & other) {
-			const size_t sz = piMin<size_t>(sz_, other.size());
-			p_->_copyRaw(p_->data(st_), other.data(), sz);
-			return *this;
-		}
-		inline PIVector<T> toVector() const { return PIVector<T>(p_->data(st_), sz_); }
-	};
-
-	class Col {
-		friend class PIVector2D<T>;
-
-	private:
-		inline Col(PIVector2D<T> * p, size_t row): p_(&(p->mat)) {
-			step_ = p->cols_;
-			row_  = row;
-			sz_   = p->rows_;
-		}
-		PIVector<T> * p_;
-		size_t step_, row_, sz_;
-
-	public:
-		inline size_t size() const { return sz_; }
-		inline T & operator[](size_t index) { return (*p_)[index * step_ + row_]; }
-		inline const T & operator[](size_t index) const { return (*p_)[index * step_ + row_]; }
-		inline T * data(size_t index = 0) { return p_->data(index * step_ + row_); }
-		inline const T * data(size_t index = 0) const { return p_->data(index * step_ + row_); }
-		inline Col & operator=(const Col & other) {
-			if (p_ == other.p_ && row_ == other.row_) return *this;
-			const size_t sz = piMin<size_t>(sz_, other.sz_);
-			for (int i = 0; i < sz; ++i)
-				(*p_)[i * step_ + row_] = other[i];
-			return *this;
-		}
-		inline Row & operator=(const PIVector<T> & other) {
-			const size_t sz = piMin<size_t>(sz_, other.size());
-			for (int i = 0; i < sz; ++i)
-				(*p_)[i * step_ + row_] = other[i];
-			return *this;
-		}
-		inline PIVector<T> toVector() const {
-			PIVector<T> ret;
-			ret.reserve(sz_);
-			for (size_t i = 0; i < sz_; i++)
-				ret << (*p_)[i * step_ + row_];
-			return ret;
-		}
-	};
 
+	//! \class RowConst
+	//! \brief
+	//! \~english Proxy class representing a single read-only row in a \a PIVector2D.
+	//! \~russian Прокси-класс, представляющий одну строку в \a PIVector2D только для чтения.
+	//! \details
+	//! \~english Returned by const \a operator[] or \a row(). Provides const access to row elements.
+	//! \~russian Возвращается константными версиями \a operator[] или \a row(). Предоставляет константный доступ к элементам строки.
+	//! \~\sa Row, ColConst
 	class RowConst {
 		friend class PIVector2D<T>;
 
-	private:
-		inline RowConst(const PIVector2D<T> * p, size_t row): p_(&(p->mat)) {
-			st_ = p->cols_ * row;
-			sz_ = p->cols_;
-		}
+	protected:
+		inline RowConst(const PIVector2D<T> * p, size_t row): p_(&(p->mat)), st_(p->cols_ * row), sz_(p->cols_) {}
 		const PIVector<T> * p_;
-		size_t st_, sz_;
+		const size_t st_, sz_;
 
 	public:
+		//! \~english Copy constructor from modifiable Row to read-only RowConst.
+		//! \~russian Конструктор копирования из модифицируемого класса Row в константный RowConst.
+		//! \~\sa Row
+		inline RowConst(const PIVector2D<T>::Row & r): p_(r.p_), st_(r.st_), sz_(r.sz_) {}
+
+		//! \~english Size of the row (number of columns).
+		//! \~russian Размер строки (количество столбцов).
 		inline size_t size() const { return sz_; }
+
+		//! \~english Const access to the element at the given column index within the row.
+		//! \~russian Константный доступ к элементу по заданному индексу столбца в строке.
 		inline const T & operator[](size_t index) const { return (*p_)[st_ + index]; }
+
+		//! \~english Returns a const pointer to the row data starting at an optional offset.
+		//! \~russian Возвращает константный указатель на данные строки, начиная с опционального смещения.
 		inline const T * data(size_t index = 0) const { return p_->data(st_ + index); }
+
+		//! \~english Converts the row to a \a PIVector.
+		//! \~russian Преобразует строку в \a PIVector.
 		inline PIVector<T> toVector() const { return PIVector<T>(p_->data(st_), sz_); }
+
+		//! \~english Returns the first index of element `e` in the row, starting from `start`.
+		//! \~russian Возвращает первый индекс элемента `e` в строке, начиная с позиции `start`.
+		//! \details
+		//! \~english See \a PIVector::indexOf() for details on negative start handling.
+		//! \~russian Подробнее об обработке отрицательного `start` см. \a PIVector::indexOf().
+		//! \~\sa PIVector::indexOf()
+		inline ssize_t indexOf(const T & e, ssize_t start = 0) const {
+			if (start < 0) start = 0;
+			for (size_t i = (size_t)start; i < sz_; ++i) {
+				if ((*p_)[st_ + i] == e) return (ssize_t)i;
+			}
+			return -1;
+		}
+
+		//! \~english Returns the last index of element `e` in the row, searching backwards from `start`.
+		//! \~russian Возвращает последний индекс элемента `e` в строке, выполняя поиск в обратном направлении от `start`.
+		//! \return Index if found, -1 otherwise.
+		//! \~\sa PIVector::lastIndexOf()
+		inline ssize_t lastIndexOf(const T & e, ssize_t start = -1) const {
+			ssize_t from = (start < 0 || (size_t)start >= sz_) ? (ssize_t)sz_ - 1 : start;
+			for (ssize_t i = from; i >= 0; --i) {
+				if ((*p_)[st_ + i] == e) return i;
+			}
+			return -1;
+		}
+
+		//! \~english Returns the first index where the predicate `test` returns true, starting from `start`.
+		//! \~russian Возвращает первый индекс, для которого предикат `test` возвращает true, начиная с `start`.
+		//! \~\sa PIVector::indexWhere()
+		inline ssize_t indexWhere(std::function<bool(const T & e)> test, ssize_t start = 0) const {
+			if (start < 0) start = 0;
+			for (size_t i = (size_t)start; i < sz_; ++i) {
+				if (test((*p_)[st_ + i])) return (ssize_t)i;
+			}
+			return -1;
+		}
+
+		//! \~english Returns the last index where the predicate `test` returns true, searching backwards from `start`.
+		//! \~russian Возвращает последний индекс, для которого предикат `test` возвращает true,
+		//! выполняя поиск в обратном направлении от `start`.
+		//! \~\sa PIVector::lastIndexWhere()
+		inline ssize_t lastIndexWhere(std::function<bool(const T & e)> test, ssize_t start = -1) const {
+			ssize_t from = (start < 0 || (size_t)start >= sz_) ? (ssize_t)sz_ - 1 : start;
+			for (ssize_t i = from; i >= 0; --i) {
+				if (test((*p_)[st_ + i])) return i;
+			}
+			return -1;
+		}
+
+		//! \~english Applies a function to each element of the row (read-only).
+		//! \~russian Применяет функцию к каждому элементу строки (только чтение).
+		//! \details
+		//! \~english The function can't modify the elements.
+		//! \~russian Функция не может изменять элементы.
+		//! \~\sa forEach (modifiable)
+		inline void forEach(std::function<void(const T &)> func) const {
+			for (size_t i = 0; i < sz_; ++i) {
+				func((*p_)[st_ + i]);
+			}
+		}
+
+		//! \~english Checks if the row contains the element `e`.
+		//! \~russian Проверяет, содержит ли строка элемент `e`.
+		//! \~\sa PIVector::contains()
+		inline bool contains(const T & e, ssize_t start = 0) const { return indexOf(e, start) != -1; }
+
+		//! \~english Counts occurrences of `e` in the row.
+		//! \~russian Подсчитывает количество вхождений `e` в строке.
+		//! \~\sa PIVector::entries()
+		inline int entries(const T & e, ssize_t start = 0) const {
+			if (start < 0) start = 0;
+			int count = 0;
+			for (size_t i = (size_t)start; i < sz_; ++i) {
+				if ((*p_)[st_ + i] == e) ++count;
+			}
+			return count;
+		}
+
+		//! \~english Counts elements in the row that pass the `test`.
+		//! \~russian Подсчитывает элементы в строке, проходящие `test`.
+		//! \~\sa PIVector::entries(std::function)
+		inline int entries(std::function<bool(const T & e)> test, ssize_t start = 0) const {
+			if (start < 0) start = 0;
+			int count = 0;
+			for (size_t i = (size_t)start; i < sz_; ++i) {
+				if (test((*p_)[st_ + i])) ++count;
+			}
+			return count;
+		}
+
+		//! \~english Tests if any element in the row passes the `test`.
+		//! \~russian Проверяет, проходит ли какой-либо элемент в строке `test`.
+		//! \~\sa PIVector::any()
+		inline bool any(std::function<bool(const T & e)> test) const {
+			for (size_t i = 0; i < sz_; ++i) {
+				if (test((*p_)[st_ + i])) return true;
+			}
+			return false;
+		}
+
+		//! \~english Tests if all elements in the row pass the `test`.
+		//! \~russian Проверяет, проходят ли все элементы в строке `test`.
+		//! \~\sa PIVector::every()
+		inline bool every(std::function<bool(const T & e)> test) const {
+			for (size_t i = 0; i < sz_; ++i) {
+				if (!test((*p_)[st_ + i])) return false;
+			}
+			return true;
+		}
 	};
 
+
+	//! \class ColConst
+	//! \brief
+	//! \~english Proxy class representing a single read-only column in a \a PIVector2D.
+	//! \~russian Прокси-класс, представляющий один столбец в \a PIVector2D только для чтения.
+	//! \details
+	//! \~english Returned by const \a col(). Provides const access to column elements.
+	//! \~russian Возвращается константной версией \a col(). Предоставляет константный доступ к элементам столбца.
+	//! \~\sa Col, RowConst
 	class ColConst {
 		friend class PIVector2D<T>;
 
-	private:
-		inline ColConst(const PIVector2D<T> * p, size_t row): p_(&(p->mat)) {
-			step_ = p->cols_;
-			row_  = row;
-			sz_   = p->rows_;
-		}
+	protected:
+		inline ColConst(const PIVector2D<T> * p, size_t col): p_(&(p->mat)), step_(p->cols_), col_(col), sz_(p->rows_) {}
 		const PIVector<T> * p_;
-		size_t step_, row_, sz_;
+		const size_t step_, col_, sz_;
 
 	public:
-		inline size_t size() const { return p_->rows_; }
-		inline const T & operator[](size_t index) const { return (*p_)[index * step_ + row_]; }
-		inline const T * data(size_t index = 0) const { return p_->data(index * step_ + row_); }
+		//! \~english Copy constructor from modifiable Col to read-only ColConst.
+		//! \~russian Конструктор копирования из модифицируемого класса Col в константный ColConst.
+		//! \~\sa Col
+		inline ColConst(const PIVector2D<T>::Col & c): p_(c.p_), step_(c.step_), col_(c.col_), sz_(c.sz_) {}
+
+		//! \~english Size of the column (number of rows).
+		//! \~russian Размер столбца (количество строк).
+		inline size_t size() const { return sz_; }
+
+		//! \~english Const access to the element at the given row index within the column.
+		//! \~russian Константный доступ к элементу по заданному индексу строки в столбце.
+		inline const T & operator[](size_t index) const { return (*p_)[index * step_ + col_]; }
+
+		//! \~english Returns a const pointer to the column data starting at an optional row offset.
+		//! \~russian Возвращает константный указатель на данные столбца, начиная с опционального смещения по строкам.
+		inline const T * data(size_t index = 0) const { return p_->data(index * step_ + col_); }
+
+		//! \~english Converts the column to a \a PIVector.
+		//! \~russian Преобразует столбец в \a PIVector.
 		inline PIVector<T> toVector() const {
 			PIVector<T> ret;
 			ret.reserve(sz_);
-			for (int i = 0; i < size(); i++)
-				ret << (*p_)[i * step_ + row_];
+			for (size_t i = 0; i < size(); i++)
+				ret << (*p_)[i * step_ + col_];
 			return ret;
 		}
+
+		//! \~english Returns the first index of element `e` in the row, starting from `start`.
+		//! \~russian Возвращает первый индекс элемента `e` в строке, начиная с позиции `start`.
+		//! \details
+		//! \~english See \a PIVector::indexOf() for details on negative start handling.
+		//! \~russian Подробнее об обработке отрицательного `start` см. \a PIVector::indexOf().
+		//! \~\sa PIVector::indexOf()
+		inline ssize_t indexOf(const T & e, ssize_t start = 0) const {
+			if (start < 0) start = 0;
+			for (size_t i = (size_t)start; i < sz_; ++i) {
+				if ((*p_)[i * step_ + col_] == e) return (ssize_t)i;
+			}
+			return -1;
+		}
+
+		//! \~english Returns the last index of element `e` in the row, searching backwards from `start`.
+		//! \~russian Возвращает последний индекс элемента `e` в строке, выполняя поиск в обратном направлении от `start`.
+		//! \~\sa PIVector::lastIndexOf()
+		inline ssize_t lastIndexOf(const T & e, ssize_t start = -1) const {
+			ssize_t from = (start < 0 || (size_t)start >= sz_) ? (ssize_t)sz_ - 1 : start;
+			for (ssize_t i = from; i >= 0; --i) {
+				if ((*p_)[i * step_ + col_] == e) return i;
+			}
+			return -1;
+		}
+
+		//! \~english Returns the first index where the predicate `test` returns true, starting from `start`.
+		//! \~russian Возвращает первый индекс, для которого предикат `test` возвращает true, начиная с `start`.
+		//! \~\sa PIVector::indexWhere()
+		inline ssize_t indexWhere(std::function<bool(const T & e)> test, ssize_t start = 0) const {
+			if (start < 0) start = 0;
+			for (size_t i = (size_t)start; i < sz_; ++i) {
+				if (test((*p_)[i * step_ + col_])) return (ssize_t)i;
+			}
+			return -1;
+		}
+
+		//! \~english Returns the last index where the predicate `test` returns true, searching backwards from `start`.
+		//! \~russian Возвращает последний индекс, для которого предикат `test` возвращает true,
+		//! выполняя поиск в обратном направлении от `start`.
+		//! \~\sa PIVector::lastIndexWhere()
+		inline ssize_t lastIndexWhere(std::function<bool(const T & e)> test, ssize_t start = -1) const {
+			ssize_t from = (start < 0 || (size_t)start >= sz_) ? (ssize_t)sz_ - 1 : start;
+			for (ssize_t i = from; i >= 0; --i) {
+				if (test((*p_)[i * step_ + col_])) return i;
+			}
+			return -1;
+		}
+
+		//! \~english Applies a function to each element of the column (read-only).
+		//! \~russian Применяет функцию к каждому элементу столбца (только чтение).
+		//! \details
+		//! \~english The function can't modify the elements.
+		//! \~russian Функция не может изменять элементы.
+		//! \~\sa forEach (modifiable)
+		inline void forEach(std::function<void(const T &)> func) const {
+			for (size_t i = 0; i < sz_; ++i) {
+				func((*p_)[i * step_ + col_]);
+			}
+		}
+
+		//! \~english Checks if the column contains the element `e`.
+		//! \~russian Проверяет, содержит ли столбец элемент `e`.
+		//! \~\sa PIVector::contains()
+		inline bool contains(const T & e, ssize_t start = 0) const { return indexOf(e, start) != -1; }
+
+		//! \~english Counts occurrences of `e` in the column.
+		//! \~russian Подсчитывает количество вхождений `e` в столбце.
+		//! \~\sa PIVector::entries()
+		inline int entries(const T & e, ssize_t start = 0) const {
+			if (start < 0) start = 0;
+			int count = 0;
+			for (size_t i = (size_t)start; i < sz_; ++i) {
+				if ((*p_)[i * step_ + col_] == e) ++count;
+			}
+			return count;
+		}
+
+		//! \~english Counts elements in the column that pass the `test`.
+		//! \~russian Подсчитывает элементы в столбце, проходящие `test`.
+		//! \~\sa PIVector::entries(std::function)
+		inline int entries(std::function<bool(const T & e)> test, ssize_t start = 0) const {
+			if (start < 0) start = 0;
+			int count = 0;
+			for (size_t i = (size_t)start; i < sz_; ++i) {
+				if (test((*p_)[i * step_ + col_])) ++count;
+			}
+			return count;
+		}
+
+		//! \~english Tests if any element in the column passes the `test`.
+		//! \~russian Проверяет, проходит ли какой-либо элемент в столбце `test`.
+		//! \~\sa PIVector::any()
+		inline bool any(std::function<bool(const T & e)> test) const {
+			for (size_t i = 0; i < sz_; ++i) {
+				if (test((*p_)[i * step_ + col_])) return true;
+			}
+			return false;
+		}
+
+		//! \~english Tests if all elements in the column pass the `test`.
+		//! \~russian Проверяет, проходят ли все элементы в столбце `test`.
+		//! \~\sa PIVector::every()
+		inline bool every(std::function<bool(const T & e)> test) const {
+			for (size_t i = 0; i < sz_; ++i) {
+				if (!test((*p_)[i * step_ + col_])) return false;
+			}
+			return true;
+		}
 	};
 
+	//! \class Row
+	//! \brief
+	//! \~english Proxy class representing a single row in a \a PIVector2D for modification.
+	//! \~russian Прокси-класс, представляющий одну строку в \a PIVector2D для модификации.
+	//! \details
+	//! \~english Objects of this class are returned by non-const \a operator[] or \a row().
+	//! They provide array-like access to the elements of a specific row and allow operations such as assignment from another row or a \a
+	//! PIVector, searching, filling, and iteration.
+	//! \~russian Объекты этого класса возвращаются неконстантными операторами \a operator[] или методом \a row().
+	//! Они предоставляют доступ к элементам конкретной строки, подобный массиву, и позволяют выполнять такие операции, как присваивание из
+	//! другой строки или \a PIVector, поиск, заполнение и итерацию. \sa Col, RowConst
+	class Row: public RowConst {
+		friend class PIVector2D<T>;
+
+	private:
+		inline Row(PIVector2D<T> * p, size_t row): RowConst(p, row), p_(&(p->mat)) {}
+		PIVector<T> * p_;
+
+	public:
+		using RowConst::operator[];
+		using RowConst::data;
+		using RowConst::size;
+
+		//! \~english Accesses the element at the given column index within the row.
+		//! \~russian Доступ к элементу по заданному индексу столбца в строке.
+		//! \details
+		//! \~english No bounds checking is performed; use with caution.
+		//! \~russian Проверка границ не выполняется; используйте с осторожностью.
+		//! \~\sa PIVector::operator[]
+		inline T & operator[](size_t index) { return (*p_)[this->st_ + index]; }
+
+		//! \~english Returns a pointer to the row data starting at an optional offset.
+		//! \~russian Возвращает указатель на данные строки, начиная с опционального смещения.
+		//! \details
+		//! \~english The pointer can be used for direct memory operations. It remains valid as long as the underlying 2D array is not
+		//! reallocated.
+		//! \~russian Указатель можно использовать для прямых операций с памятью. Он остаётся действительным, пока не произойдёт
+		//! перераспределение памяти внутреннего двумерного массива. \sa PIVector::data()
+		inline T * data(size_t index = 0) { return p_->data(this->st_ + index); }
+
+		//! \~english Assigns the contents of another Row to this row.
+		//! \~russian Присваивает этой строке содержимое другой строки.
+		//! \details
+		//! \~english Only the minimum of the two row sizes is copied; if this row is shorter, excess elements in `other` are ignored.
+		//! \~russian Копируется только минимум из размеров двух строк; если эта строка короче, лишние элементы из `other` игнорируются.
+		//! \~\sa PIVector::operator=
+		inline Row & operator=(const Row & other) {
+			if (p_ == other.p_ && this->st_ == other.st_) return *this;
+			const size_t sz = piMin<size_t>(this->sz_, other.sz_);
+			p_->_copyRaw(p_->data(this->st_), other.data(), sz);
+			return *this;
+		}
+
+		//! \~english Assigns the contents of a \a PIVector to this row.
+		//! \~russian Присваивает этой строке содержимое \a PIVector.
+		//! \details
+		//! \~english Only the minimum of the row size and vector size is copied.
+		//! \~russian Копируется только минимум из размера строки и размера вектора.
+		//! \~\sa PIVector::operator=
+		inline Row & operator=(const PIVector<T> & other) {
+			const size_t sz = piMin<size_t>(this->sz_, other.size());
+			p_->_copyRaw(p_->data(this->st_), other.data(), sz);
+			return *this;
+		}
+
+		//! \~english Applies a function to each element of the row (modifiable).
+		//! \~russian Применяет функцию к каждому элементу строки (с возможностью изменения).
+		//! \param func Function that takes a reference to T.
+		//! \details
+		//! \~english The function can modify the elements.
+		//! \~russian Функция может изменять элементы.
+		//! \~\sa PIVector::forEach()
+		inline void forEach(std::function<void(T &)> func) {
+			for (size_t i = 0; i < this->sz_; ++i) {
+				func((*p_)[this->st_ + i]);
+			}
+		}
+
+		//! \~english Fills the row with copies of `value`.
+		//! \~russian Заполняет строку копиями `value`.
+		//! \~\sa PIVector::fill()
+		inline void fill(const T & value) {
+			for (size_t i = 0; i < this->sz_; ++i) {
+				(*p_)[this->st_ + i] = value;
+			}
+		}
+	};
+
+
+	//! \class Col
+	//! \brief
+	//! \~english Proxy class representing a single column in a \a PIVector2D for modification.
+	//! \~russian Прокси-класс, представляющий один столбец в \a PIVector2D для модификации.
+	//! \details
+	//! \~english Objects of this class are returned by non-const \a col(). They provide column-wise access and operations similar to \a
+	//! Row.
+	//! \~russian Объекты этого класса возвращаются неконстантным методом \a col(). Они предоставляют доступ к столбцам и операции,
+	//! аналогичные \a Row. \sa Row, ColConst
+	class Col: public ColConst {
+		friend class PIVector2D<T>;
+
+	private:
+		inline Col(PIVector2D<T> * p, size_t col): ColConst(p, col), p_(&(p->mat)) {}
+		PIVector<T> * p_;
+
+	public:
+		using ColConst::operator[];
+		using ColConst::data;
+		using ColConst::size;
+
+		//! \~english Accesses the element at the given row index within the column.
+		//! \~russian Доступ к элементу по заданному индексу строки в столбце.
+		//! \return Reference to the element.
+		inline T & operator[](size_t index) { return (*p_)[index * this->step_ + this->col_]; }
+
+		//! \~english Returns a pointer to the column data starting at an optional row offset.
+		//! \~russian Возвращает указатель на данные столбца, начиная с опционального смещения по строкам.
+		//! \details
+		//! \~english Note that column elements are not stored contiguously in memory, so this pointer cannot be used to iterate over the
+		//! whole column.
+		//! \~russian Обратите внимание, что элементы столбца не хранятся в памяти непрерывно, поэтому этот указатель нельзя использовать
+		//! для итерации по всему столбцу.
+		inline T * data(size_t index = 0) { return p_->data(index * this->step_ + this->col_); }
+
+		//! \~english Assigns the contents of another Col to this column.
+		//! \~russian Присваивает этому столбцу содержимое другого столбца.
+		inline Col & operator=(const Col & other) {
+			if (p_ == other.p_ && this->col_ == other.col_) return *this;
+			const size_t sz = piMin<size_t>(this->sz_, other.sz_);
+			for (size_t i = 0; i < sz; ++i)
+				(*p_)[i * this->step_ + this->col_] = other[i];
+			return *this;
+		}
+
+		//! \~english Assigns the contents of a \a PIVector to this column.
+		//! \~russian Присваивает этому столбцу содержимое \a PIVector.
+		inline Col & operator=(const PIVector<T> & other) {
+			const size_t sz = piMin<size_t>(this->sz_, other.size());
+			for (size_t i = 0; i < sz; ++i)
+				(*p_)[i * this->step_ + this->col_] = other[i];
+			return *this;
+		}
+
+		//! \~english Applies a function to each element of the column (modifiable).
+		//! \~russian Применяет функцию к каждому элементу столбца (с возможностью изменения).
+		//! \details
+		//! \~english The function can modify the elements.
+		//! \~russian Функция может изменять элементы.
+		//! \~\sa PIVector::forEach()
+		inline void forEach(std::function<void(T &)> func) {
+			for (size_t i = 0; i < this->sz_; ++i) {
+				func((*p_)[i * this->step_ + this->col_]);
+			}
+		}
+
+		//! \~english Fills the column with copies of `value`.
+		//! \~russian Заполняет столбец копиями `value`.
+		//! \~\sa PIVector::fill()
+		inline void fill(const T & value) {
+			for (size_t i = 0; i < this->sz_; ++i) {
+				(*p_)[i * this->step_ + this->col_] = value;
+			}
+		}
+	};
+
+
+	//! \~english Returns a reference to the element at the given row and column.
+	//! \~russian Возвращает ссылку на элемент по заданной строке и столбцу.
+	//! \details
+	//! \~english No bounds checking is performed.
+	//! \~russian Проверка границ не выполняется.
+	//! \~\sa at() (const version), PIVector::operator[]
 	inline T & element(size_t row, size_t col) { return mat[row * cols_ + col]; }
+
+	//! \~english Returns a const reference to the element at the given row and column.
+	//! \~russian Возвращает константную ссылку на элемент по заданной строке и столбцу.
 	inline const T & element(size_t row, size_t col) const { return mat[row * cols_ + col]; }
+
+	//! \~english Returns a const reference to the element at the given row and column
+	//! \~russian Возвращает константную ссылку на элемент по заданной строке и столбцу
+	//! \details
+	//! \~english No bounds checking is performed.
+	//! \~russian Проверка границ не выполняется.
 	inline const T & at(size_t row, size_t col) const { return mat[row * cols_ + col]; }
+
+	//! \~english Returns a reference to the element at the given Index.
+	//! \~russian Возвращает ссылку на элемент по заданному Index.
+	inline T & operator[](const Index & idx) { return element(idx.row, idx.col); }
+
+	//! \~english Returns a const reference to the element at the given Index.
+	//! \~russian Возвращает константную ссылку на элемент по заданному Index.
+	inline const T & operator[](const Index & idx) const { return element(idx.row, idx.col); }
+
+	//! \~english Returns a reference to the element at the given Index.
+	//! \~russian Возвращает ссылку на элемент по заданному Index.
+	inline T & element(const Index & idx) { return element(idx.row, idx.col); }
+
+	//! \~english Returns a const reference to the element at the given Index.
+	//! \~russian Возвращает константную ссылку на элемент по заданному Index.
+	inline const T & element(const Index & idx) const { return element(idx.row, idx.col); }
+
+	//! \~english Returns a const reference to the element at the given Index (bounds-checked only in debug).
+	//! \~russian Возвращает константную ссылку на элемент по заданному Index (проверка границ только в отладочном режиме).
+	inline const T & at(const Index & idx) const { return at(idx.row, idx.col); }
+
+	//! \~english Returns a proxy object for the row at the given index for modification.
+	//! \~russian Возвращает прокси-объект для строки по заданному индексу для модификации.
+	//! \~\sa row(), Col
 	inline Row operator[](size_t index) { return Row(this, index); }
+
+	//! \~english Returns a proxy object for the row at the given index for read-only access.
+	//! \~russian Возвращает прокси-объект для строки по заданному индексу только для чтения.
 	inline RowConst operator[](size_t index) const { return RowConst(this, index); }
+
+	//! \~english Returns a pointer to the underlying flat data starting at an optional offset.
+	//! \~russian Возвращает указатель на внутренние плоские данные, начиная с опционального смещения.
+	//! \~\sa PIVector::data()
 	inline T * data(size_t index = 0) { return mat.data(index); }
+
+	//! \~english Returns a const pointer to the underlying flat data starting at an optional offset.
+	//! \~russian Возвращает константный указатель на внутренние плоские данные, начиная с опционального смещения.
 	inline const T * data(size_t index = 0) const { return mat.data(index); }
 
+
+	//! \~english Returns a proxy object for the row at the given index for modification.
+	//! \~russian Возвращает прокси-объект для строки по заданному индексу для модификации.
+	//! \~\sa operator[]
 	inline Row row(size_t index) { return Row(this, index); }
+
+	//! \~english Returns a proxy object for the row at the given index for read-only access.
+	//! \~russian Возвращает прокси-объект для строки по заданному индексу только для чтения.
 	inline RowConst row(size_t index) const { return RowConst(this, index); }
+
+	//! \~english Returns a proxy object for the column at the given index for modification.
+	//! \~russian Возвращает прокси-объект для столбца по заданному индексу для модификации.
+	//! \~\sa col() const
 	inline Col col(size_t index) { return Col(this, index); }
+
+	//! \~english Returns a proxy object for the column at the given index for read-only access.
+	//! \~russian Возвращает прокси-объект для столбца по заданному индексу только для чтения.
 	inline ColConst col(size_t index) const { return ColConst(this, index); }
-	inline PIVector2D<T> & setRow(size_t row, const Row & other) {
-		const size_t sz = piMin<size_t>(cols_, other.sz_);
-		mat._copyRaw(mat.data(cols_ * row), other.data(), sz);
-		return *this;
-	}
+
+	//! \~english Replaces a row with the contents of a read-only RowConst object.
+	//! \~russian Заменяет строку содержимым объекта RowConst только для чтения.
 	inline PIVector2D<T> & setRow(size_t row, const RowConst & other) {
 		const size_t sz = piMin<size_t>(cols_, other.sz_);
 		mat._copyRaw(mat.data(cols_ * row), other.data(), sz);
 		return *this;
 	}
+
+	//! \~english Replaces a row with the contents of a \a PIVector.
+	//! \~russian Заменяет строку содержимым \a PIVector.
 	inline PIVector2D<T> & setRow(size_t row, const PIVector<T> & other) {
 		const size_t sz = piMin<size_t>(cols_, other.size());
 		mat._copyRaw(mat.data(cols_ * row), other.data(), sz);
 		return *this;
 	}
-	inline PIVector2D<T> & addRow(const Row & other) {
-		if (cols_ == 0) cols_ = other.sz_;
-		const size_t sz = piMin<size_t>(cols_, other.sz_);
-		const size_t ps = mat.size();
-		mat.resize(mat.size() + cols_);
-		mat._copyRaw(mat.data(ps), other.data(), sz);
-		rows_++;
-		return *this;
-	}
+
+	//! \~english Appends a new row to the bottom of the array from another Row object.
+	//! \~russian Добавляет новую строку в конец массива из другого объекта Row.
+	//! \details
+	//! \~english If the array was empty, its column count is set to the size of the source row.
+	//! Otherwise, only `min(cols(), other.size())` elements are copied; the rest of the new row is default-initialized.
+	//! \~russian Если массив был пуст, количество столбцов устанавливается равным размеру исходной строки.
+	//! В противном случае копируется только `min(cols(), other.size())` элементов; остальные элементы новой строки инициализируются по
+	//! умолчанию.
+	//! \~\sa PIVector::push_back()
 	inline PIVector2D<T> & addRow(const RowConst & other) {
 		if (cols_ == 0) cols_ = other.sz_;
-		const size_t sz = piMin<size_t>(cols_, other.sz_);
-		const size_t ps = mat.size();
-		mat.resize(mat.size() + cols_);
-		mat._copyRaw(mat.data(ps), other.data(), sz);
+		mat.append(other.toVector());
 		rows_++;
+		mat.resize(rows_ * cols_);
 		return *this;
 	}
+
+	//! \~english Appends a new row to the bottom of the array from a \a PIVector.
+	//! \~russian Добавляет новую строку в конец массива из \a PIVector.
 	inline PIVector2D<T> & addRow(const PIVector<T> & other) {
 		if (cols_ == 0) cols_ = other.size();
-		const size_t sz = piMin<size_t>(cols_, other.size());
-		const size_t ps = mat.size();
-		mat.resize(mat.size() + cols_);
-		mat._copyRaw(mat.data(ps), other.data(), sz);
+		mat.append(other);
 		rows_++;
+		mat.resize(rows_ * cols_);
 		return *this;
 	}
 
+	//! \~english Appends \a count new empty rows to the bottom of the array, filled with value \a f.
+	//! \~russian Добавляет \a count новых пустых строк в конец массива, заполненных значением \a f.
+	//! \details
+	//! \~english If the array was empty (no columns defined), the column count is set to 1.
+	//! The new rows are filled with the default value \a f.
+	//! \~russian Если массив был пуст (количество столбцов не определено), количество столбцов устанавливается равным 1.
+	//! Новые строки заполняются значением по умолчанию \a f.
+	//! \~\sa addRow(), appendColumns()
+	inline PIVector2D<T> & appendRows(size_t count, const T & f = T()) {
+		if (count == 0) return *this;
+		if (cols_ == 0) ++cols_;
+		mat.resize(mat.size() + count * cols_, f);
+		rows_ += count;
+		return *this;
+	}
+
+	//! \~english Appends \a count new empty columns to the end of each row of the array.
+	//! \~russian Добавляет \a count новых пустых столбцов в конец каждой строки массива.
+	//! \details
+	//! \~english If the array was empty (rows not defined), the array becomes a single row with \a count columns.
+	//! If the array already has rows, new elements are inserted at the end of each existing row.
+	//! \~russian Если массив был пуст (строки не определены), массив становится одной строкой с \a count столбцов.
+	//! Если массив уже содержит строки, новые элементы добавляются в конец каждой существующей строки.
+	//! \~\sa appendRows(), addColumn()
+	inline PIVector2D<T> & appendColumns(size_t count, const T & f = T()) {
+		if (count == 0) return *this;
+		if (rows_ == 0) {
+			mat.resize(count, f);
+			rows_ = 1;
+			cols_ = count;
+			return *this;
+		}
+
+		const size_t newCols = cols_ + count;
+		mat.reserve(rows_ * newCols);
+		for (size_t r = rows_; r > 0; --r) {
+			mat.insert(r * cols_, f, count);
+		}
+
+		cols_ = newCols;
+		return *this;
+	}
+
+	//! \~english Deletes `count` rows starting from the specified row index.
+	//! \~russian Удаляет `count` строк, начиная с указанного индекса строки.
+	//! \details
+	//! \~english Removes the specified rows from the array and updates the row count. If all elements are deleted (array becomes empty),
+	//! both rows and columns are set to 0.
+	//! \~russian Удаляет указанные строки из массива и обновляет количество строк. Если все элементы удалены (массив становится пустым),
+	//! количество строк и столбцов устанавливается в 0.
+	//! \~\sa deleteColumns()
+	inline PIVector2D<T> & deleteRows(size_t row_start, size_t count) {
+		if (row_start >= rows_ || count == 0) return *this;
+		mat.remove(row_start * cols_, cols_ * count);
+		if (isEmpty()) {
+			cols_ = 0;
+			rows_ = 0;
+		} else {
+			rows_ -= count;
+		}
+		return *this;
+	}
+
+	//! \~english Removes the specified columns from the array and updates the column count.
+	//! \~russian Удаляет указанные столбцы из массива и обновляет количество столбцов.
+	//! \details
+	//! \~english Removes \a count columns starting from \a col_start. If \a col_start is out of range or \a count is 0,
+	//! the function does nothing. If \a count extends beyond the last column, only available columns are deleted.
+	//! \~russian Удаляет \a count столбцов начиная с \a col_start. Если \a col_start выходит за границы или \a count равен 0,
+	//! функция ничего не делает. Если \a count выходит за последний столбец, удаляются только доступные столбцы.
+	//! \~\sa removeColumn(), deleteRows()
+	inline PIVector2D<T> & deleteColumns(size_t col_start, size_t count) {
+		if (col_start >= cols_ || rows_ == 0) return *this;
+		count = piMin(count, cols_ - col_start);
+		if (count == 0) return *this;
+		for (size_t r = 0; r < rows_; ++r) {
+			mat.remove(r * (cols_ - count) + col_start, count);
+		}
+		cols_ -= count;
+		mat.resize(rows_ * cols_);
+		return *this;
+	}
+
+	//! \~english Appends a new column to the right of the array from a \a ColConst.
+	//! \~russian Добавляет новую строку в конец массива из \a ColConst.
+	inline PIVector2D<T> & addColumn(const ColConst & other) {
+		if (other.size() == 0) return *this;
+		if (isEmpty()) {
+			mat.reserve(other.size());
+			for (size_t r = 0; r < other.size(); ++r) {
+				mat.append(other[r]);
+			}
+			rows_ = mat.size();
+			cols_ = 1;
+			return *this;
+		}
+
+		const size_t newCols = cols_ + 1;
+		mat.reserve(rows_ * newCols);
+		for (size_t r = rows_; r > 0; --r) {
+			if (r - 1 < other.size()) {
+				mat.insert(r * cols_, other[r - 1]);
+			} else {
+				mat.insert(r * cols_);
+			}
+		}
+
+		cols_ = newCols;
+		return *this;
+	}
+
+	//! \~english Appends a new column to the right of the array from a \a PIVector.
+	//! \~russian Добавляет новую строку в конец массива из \a PIVector.
+	inline PIVector2D<T> & addColumn(const PIVector<T> & other) {
+		if (other.size() == 0) return *this;
+		if (isEmpty()) {
+			mat.append(other);
+			rows_ = mat.size();
+			cols_ = 1;
+			return *this;
+		}
+
+		const size_t newCols = cols_ + 1;
+		mat.reserve(rows_ * newCols);
+		for (size_t r = rows_; r > 0; --r) {
+			if (r - 1 < other.size()) {
+				mat.insert(r * cols_, other[r - 1]);
+			} else {
+				mat.insert(r * cols_);
+			}
+		}
+
+		cols_ = newCols;
+		return *this;
+	}
+
+	//! \~english Resizes the 2D array to new dimensions.
+	//! \~russian Изменяет размер двумерного массива.
+	//! \details
+	//! \~english If the new dimensions are larger, new elements are appended and filled with copies of `f`.
+	//! If they are smaller, the array is truncated (excess elements are destroyed). The underlying memory may be reallocated.
+	//! \~russian Если новые размеры больше текущих, новые элементы добавляются в конец и заполняются копиями `f`.
+	//! Если новые размеры меньше, массив усекается (лишние элементы уничтожаются). Внутренняя память может быть перераспределена.
+	//! \code
+	//! PIVector2D<int> mat(2, 3, 0); // 2x3 matrix filled with 0
+	//! mat.resize(3, 4, 1);          // becomes 3x4, new elements filled with 1
+	//! \endcode
+	//! \~\sa PIVector::resize()
 	inline PIVector2D<T> & resize(size_t rows, size_t cols, const T & f = T()) {
-		mat.resize(rows * cols_, f);
-		rows_        = rows;
-		const int cs = (cols - cols_);
-		if (cs < 0) {
-			for (size_t r = 0; r < rows; ++r) {
-				mat.remove(r * cols + cols, -cs);
-			}
+		if (rows == rows_ && cols == cols_) return *this;
+		if (rows_ == 0 || cols_ == 0) {
+			mat.resize(rows * cols, f);
+			rows_ = rows;
+			cols_ = cols;
+			return *this;
 		}
-		mat.resize(rows * cols, f);
-		if (!mat.isEmpty()) {
-			if (cs > 0) {
-				for (size_t r = 0; r < rows_; ++r) {
-					for (int i = 0; i < cs; ++i)
-						mat.insert(r * cols + cols_, mat.take_back());
-				}
-			}
+		if (rows != rows_ && cols == cols_) {
+			mat.resize(rows * cols_, f);
+			rows_ = rows;
+			return *this;
+		}
+		if (cols > cols_) {
+			appendColumns(cols - cols_, f);
+		}
+		if (rows > rows_) {
+			appendRows(rows - rows_, f);
+		}
+		if (cols < cols_) {
+			deleteColumns(cols, cols_ - cols);
+		}
+		if (rows < rows_) {
+			deleteRows(rows, rows_ - rows);
 		}
-		cols_ = cols;
 		return *this;
 	}
 
+	//! \~english Equality operator.
+	//! \~russian Оператор равенства.
+	//! \~\sa PIVector::operator==
 	inline bool operator==(const PIVector2D<T> & t) const {
 		if (cols_ != t.cols_ || rows_ != t.rows_) return false;
 		return mat == t.mat;
 	}
+
+	//! \~english Inequality operator.
+	//! \~russian Оператор неравенства.
 	inline bool operator!=(const PIVector2D<T> & t) const { return !(*this == t); }
 
+	//! \~english Converts the 2D array to a vector of vectors (PIVector<PIVector<T>>).
+	//! \~russian Преобразует двумерный массив в вектор векторов (PIVector<PIVector<T>>).
+	//! \details
+	//! \~english Each row vector is a copy of the corresponding row.
+	//! \~russian Каждый вектор-строка является копией соответствующей строки.
+	//! \~\sa fromVectors(), PIVector::PIVector(const T*, size_t)
 	inline PIVector<PIVector<T>> toVectors() const {
 		PIVector<PIVector<T>> ret;
 		ret.reserve(rows_);
@@ -284,18 +1005,31 @@ public:
 		return ret;
 	}
 
+	//! \~english Returns a const reference to the underlying flat \a PIVector.
+	//! \~russian Возвращает константную ссылку на внутренний плоский \a PIVector.
+	inline const PIVector<T> & asPlainVector() const { return mat; }
+
+	//! \~english Returns a reference to the underlying flat \a PIVector.
+	//! \~russian Возвращает ссылку на внутренний плоский \a PIVector.
+	inline PIVector<T> & asPlainVector() { return mat; }
+
+	//! \~english Returns a copy of the underlying flat \a PIVector.
+	//! \~russian Возвращает копию внутреннего плоского \a PIVector.
 	inline PIVector<T> toPlainVector() const { return mat; }
 
-	inline PIVector<T> & plainVector() { return mat; }
-
-	inline const PIVector<T> & plainVector() const { return mat; }
-
+	//! \~english Swaps this 2D array with another.
+	//! \~russian Меняет местами этот двумерный массив с другим.
+	//! \details
+	//! \~english Swaps the flat vectors and the dimension members. Very fast, no memory allocation.
+	//! \~russian Обменивает внутренние плоские векторы и члены, хранящие размеры. Очень быстро, без выделения памяти.
+	//! \~\sa PIVector::swap()
 	inline void swap(PIVector2D<T> & other) {
 		mat.swap(other.mat);
 		piSwap<size_t>(rows_, other.rows_);
 		piSwap<size_t>(cols_, other.cols_);
 	}
 
+	//! \internal
 	template<typename T1 = T, typename std::enable_if<std::is_trivially_copyable<T1>::value, int>::type = 0>
 	inline PIVector2D<T> & _resizeRaw(size_t r, size_t c) {
 		rows_ = r;
@@ -304,29 +1038,348 @@ public:
 		return *this;
 	}
 
+	//! \~english Clears the array, removing all elements and setting dimensions to 0.
+	//! \~russian Очищает массив, удаляя все элементы и устанавливая размеры в 0.
+	//! \details
+	//! \~english The capacity of the underlying flat vector may remain unchanged.
+	//! \~russian Ёмкость внутреннего плоского вектора может остаться неизменной.
+	//! \~\sa PIVector::clear()
 	inline void clear() {
 		rows_ = cols_ = 0;
 		mat.clear();
 	}
 
-	template<typename ST>
-	inline PIVector2D<ST> map(std::function<ST(const T & e)> f) const {
-		return PIVector2D<ST>(rows_, cols_, mat.map(f));
+
+	//! \~english Checks if the underlying flat vector contains the element `e`.
+	//! \~russian Проверяет, содержит ли внутренний плоский вектор элемент `e`.
+	//! \~\sa PIVector::contains()
+	inline bool contains(const T & e) const { return mat.contains(e); }
+
+	//! \~english Counts occurrences of `e` in the underlying flat vector.
+	//! \~russian Подсчитывает количество вхождений `e` во внутреннем плоском векторе.
+	//! \~\sa PIVector::entries()
+	inline int entries(const T & e) const { return mat.entries(e); }
+
+	//! \~english Counts elements in the flat vector that pass the `test`.
+	//! \~russian Подсчитывает элементы в плоском векторе, проходящие `test`.
+	//! \~\sa PIVector::entries(std::function)
+	inline int entries(std::function<bool(const T & e)> test) const { return mat.entries(test); }
+
+
+	//! \~english Returns the first index (row, col) of `e` in the 2D array.
+	//! \~russian Возвращает первый индекс (строка, столбец) элемента `e` в двумерном массиве.
+	//! \~\sa PIVector::indexOf()
+	inline Index indexOf(const T & e) const {
+		ssize_t flat = mat.indexOf(e);
+		if (flat < 0 || cols_ == 0) return Index{-1, -1};
+		return Index{flat / static_cast<ssize_t>(cols_), flat % static_cast<ssize_t>(cols_)};
 	}
 
-	inline void forEach(std::function<void(const T &)> f) const { mat.forEach(f); }
+	//! \~english Returns the first index (row, col) in the 2D array that passes the `test`.
+	//! \~russian Возвращает первый индекс (строка, столбец) в двумерном массиве, проходящий `test`.
+	//! \~\sa PIVector::indexWhere()
+	inline Index indexWhere(std::function<bool(const T & e)> test, ssize_t start = 0) const {
+		ssize_t flat = mat.indexWhere(test, start);
+		if (flat < 0 || cols_ == 0) return Index{-1, -1};
+		return Index{flat / static_cast<ssize_t>(cols_), flat % static_cast<ssize_t>(cols_)};
+	}
 
-	inline PIVector2D<T> & forEach(std::function<void(T &)> f) {
-		mat.forEach(f);
+	//! \~english Returns the last index (row, col) of `e` in the 2D array.
+	//! \~russian Возвращает последний индекс (строка, столбец) элемента `e` в двумерном массиве.
+	//! \~\sa PIVector::lastIndexOf()
+	inline Index lastIndexOf(const T & e, ssize_t start = -1) const {
+		ssize_t flat = mat.lastIndexOf(e, start);
+		if (flat < 0 || cols_ == 0) return Index{-1, -1};
+		return Index{flat / static_cast<ssize_t>(cols_), flat % static_cast<ssize_t>(cols_)};
+	}
+
+	//! \~english Returns the last index (row, col) in the 2D array that passes the `test`.
+	//! \~russian Возвращает последний индекс (строка, столбец) в двумерном массиве, проходящий `test`.
+	//! \~\sa PIVector::lastIndexWhere()
+	inline Index lastIndexWhere(std::function<bool(const T & e)> test, ssize_t start = -1) const {
+		ssize_t flat = mat.lastIndexWhere(test, start);
+		if (flat < 0 || cols_ == 0) return Index{-1, -1};
+		return Index{flat / static_cast<ssize_t>(cols_), flat % static_cast<ssize_t>(cols_)};
+	}
+
+
+	//! \~english Tests if any element in the flat vector passes the `test`.
+	//! \~russian Проверяет, проходит ли какой-либо элемент в плоском векторе `test`.
+	//! \~\sa PIVector::any()
+	inline bool any(std::function<bool(const T & e)> test) const { return mat.any(test); }
+
+	//! \~english Tests if all elements in the flat vector pass the `test`.
+	//! \~russian Проверяет, проходят ли все элементы в плоском векторе `test`.
+	//! \~\sa PIVector::every()
+	inline bool every(std::function<bool(const T & e)> test) const { return mat.every(test); }
+
+	//! \~english Fills the entire 2D array with copies of `e`.
+	//! \~russian Заполняет весь двумерный массив копиями `e`.
+	//! \~\sa PIVector::fill()
+	inline PIVector2D<T> & fill(const T & e = T()) {
+		mat.fill(e);
 		return *this;
 	}
 
+	//! \~english Fills the entire 2D array using a generator function `f` based on flat index.
+	//! \~russian Заполняет весь двумерный массив, используя функцию-генератор `f` на основе плоского индекса.
+	//! \~\sa PIVector::fill(std::function)
+	inline PIVector2D<T> & fill(std::function<T(size_t i)> f) {
+		mat.fill(f);
+		return *this;
+	}
+
+	//! \~english Same as \a fill().
+	//! \~russian То же, что и \a fill().
+	inline PIVector2D<T> & assign(const T & e = T()) { return fill(e); }
+
+	//! \~english Assigns new size and fills with value.
+	//! \~russian Задаёт новый размер и заполняет значением.
+	//! \~\sa PIVector::assign(size_t, const T&)
+	inline PIVector2D<T> & assign(size_t rows, size_t cols, const T & f = T()) {
+		mat.assign(rows * cols, f);
+		rows_ = rows;
+		cols_ = cols;
+		return *this;
+	}
+
+
+	//! \~english Returns a transposed 2D array (rows become columns and vice versa).
+	//! \~russian Возвращает транспонированный двумерный массив (строки становятся столбцами и наоборот).
+	//! \details
+	//! \~english The element at (r, c) in the original becomes at (c, r) in the result.
+	//! \~russian Элемент (r, c) исходного массива становится элементом (c, r) в результате.
+	//! \code
+	//! PIVector2D<int> mat(2, 3, ...);
+	//! auto t = mat.transposed(); // now 3x2
+	//! \endcode
+	inline PIVector2D<T> transposed() const {
+		if (isEmpty()) return PIVector2D<T>();
+		PIVector2D<T> result(cols_, rows_);
+		for (size_t r = 0; r < rows_; ++r) {
+			for (size_t c = 0; c < cols_; ++c) {
+				result.element(c, r) = element(r, c);
+			}
+		}
+		return result;
+	}
+
+	//! \~english Reverses the order of rows in place.
+	//! \~russian Изменяет порядок строк на обратный на месте.
+	//! \~\sa reverseColumns(), PIVector::reverse()
+	inline PIVector2D<T> & reverseRows() {
+		const size_t half = rows_ / 2;
+		for (size_t i = 0; i < half; ++i) {
+			T * row1 = data(i * cols_);
+			T * row2 = data((rows_ - 1 - i) * cols_);
+			for (size_t j = 0; j < cols_; ++j) {
+				piSwap(row1[j], row2[j]);
+			}
+		}
+		return *this;
+	}
+
+	//! \~english Reverses the order of columns in each row in place.
+	//! \~russian Изменяет порядок столбцов в каждой строке на обратный на месте.
+	//! \~\sa reverseRows(), PIVector::reverse()
+	inline PIVector2D<T> & reverseColumns() {
+		for (size_t r = 0; r < rows_; ++r) {
+			Row currentRow    = row(r);
+			const size_t half = cols_ / 2;
+			for (size_t c = 0; c < half; ++c) {
+				piSwap<T>(currentRow[c], currentRow[cols_ - 1 - c]);
+			}
+		}
+		return *this;
+	}
+
+	//! \~english Returns a sub-2D array (a range of rows and columns).
+	//! \~russian Возвращает подмассив (диапазон строк и столбцов).
+	//! \details
+	//! \~english If the range exceeds the array boundaries, it is clipped. If rowCount or colCount is 0, an empty array is returned.
+	//! \~russian Если диапазон выходит за границы массива, он обрезается. Если rowCount или colCount равны 0, возвращается пустой массив.
+	//! \~\sa PIVector::getRange()
+	inline PIVector2D<T> getRange(size_t rowStart, size_t rowCount, size_t colStart, size_t colCount) const {
+		if (rowStart >= rows_ || colStart >= cols_ || rowCount == 0 || colCount == 0) return PIVector2D<T>();
+		const size_t actualRowCount = piMin<size_t>(rowCount, rows_ - rowStart);
+		const size_t actualColCount = piMin<size_t>(colCount, cols_ - colStart);
+
+		PIVector2D<T> result(actualRowCount, actualColCount);
+		for (size_t r = 0; r < actualRowCount; ++r) {
+			for (size_t c = 0; c < actualColCount; ++c) {
+				result.element(r, c) = element(rowStart + r, colStart + c);
+			}
+		}
+		return result;
+	}
+
+	//! \~english Applies a function to each element and returns a new 2D array of a different type.
+	//! \~russian Применяет функцию к каждому элементу и возвращает новый двумерный массив другого типа.
+	//! \details
+	//! \~english The original array is not modified.
+	//! \~russian Исходный массив не изменяется.
+	//! \~\sa PIVector::map()
+	template<typename ST>
+	inline PIVector2D<ST> map(std::function<ST(const T & e)> f) const {
+		return PIVector2D<ST>(rows_, cols_, mat.template map<ST>(f));
+	}
+
+	//! \~english Applies a function (with row and col indices) to each element and returns a new 2D array.
+	//! \~russian Применяет функцию (с индексами строки и столбца) к каждому элементу и возвращает новый двумерный массив.
+	//! \~\sa PIVector::mapIndexed()
+	template<typename ST>
+	inline PIVector2D<ST> mapIndexed(std::function<ST(size_t row, size_t col, const T & e)> f) const {
+		PIVector<ST> mappedMat;
+		mappedMat.reserve(size());
+		for (size_t r = 0; r < rows_; ++r) {
+			for (size_t c = 0; c < cols_; ++c) {
+				mappedMat << f(r, c, element(r, c));
+			}
+		}
+		return PIVector2D<ST>(rows_, cols_, std::move(mappedMat));
+	}
+
+	//! \~english Applies a function to each row (modifiable).
+	//! \~russian Применяет функцию к каждой строке (с возможностью изменения).
+	//! \~\sa forEachRow() const, PIVector::forEach()
+	inline PIVector2D<T> & forEachRow(std::function<void(Row)> f) {
+		for (size_t r = 0; r < rows_; ++r)
+			f(row(r));
+		return *this;
+	}
+
+	//! \~english Applies a function to each row (read-only).
+	//! \~russian Применяет функцию к каждой строке (только чтение).
+	inline void forEachRow(std::function<void(RowConst)> f) const {
+		for (size_t r = 0; r < rows_; ++r)
+			f(row(r));
+	}
+
+	//! \~english Applies a function to each column (modifiable).
+	//! \~russian Применяет функцию к каждому столбцу (с возможностью изменения).
+	inline PIVector2D<T> & forEachColumn(std::function<void(Col)> f) {
+		for (size_t c = 0; c < cols_; ++c)
+			f(col(c));
+		return *this;
+	}
+
+	//! \~english Applies a function to each column (read-only).
+	//! \~russian Применяет функцию к каждому столбцу (только чтение).
+	//! \param f Function taking a \a ColConst.
+	inline void forEachColumn(std::function<void(ColConst)> f) const {
+		for (size_t c = 0; c < cols_; ++c)
+			f(col(c));
+	}
+
+	//! \~english Accumulates a value across all elements.
+	//! \~russian Аккумулирует значение по всем элементам.
+	//! \~\sa PIVector::reduce()
+	template<typename ST>
+	inline ST reduce(std::function<ST(const T & e, const ST & acc)> f, const ST & initial = ST()) const {
+		return mat.template reduce<ST>(f, initial);
+	}
+
+	//! \~english Accumulates a value across all elements with indices.
+	//! \~russian Аккумулирует значение по всем элементам с индексами.
+	//! \~\sa PIVector::reduceIndexed()
+	template<typename ST>
+	inline ST reduceIndexed(std::function<ST(size_t row, size_t col, const T & e, const ST & acc)> f, const ST & initial = ST()) const {
+		ST ret(initial);
+		for (size_t r = 0; r < rows_; ++r) {
+			for (size_t c = 0; c < cols_; ++c) {
+				ret = f(r, c, element(r, c), ret);
+			}
+		}
+		return ret;
+	}
+
+	//! \~english Removes a row from the 2D array.
+	//! \~russian Удаляет строку из двумерного массива.
+	//! \details
+	//! \~english If the last row is removed and the array becomes empty, \a cols() is set to 0.
+	//! \~russian Если удаляется последняя строка и массив становится пустым, \a cols() устанавливается в 0.
+	//! \~\sa removeColumn(), PIVector::remove()
+	inline PIVector2D<T> & removeRow(size_t row) { return deleteRows(row, 1); }
+
+	//! \~english Removes a column from the 2D array.
+	//! \~russian Удаляет столбец из двумерного массива.
+	//! \details
+	//! \~english This operation is more expensive than removing a row because elements must be moved.
+	//! \~russian Эта операция дороже, чем удаление строки, поскольку требуется перемещение элементов.
+	//! \~\sa removeRow(), PIVector::remove()
+	inline PIVector2D<T> & removeColumn(size_t col) { return deleteColumns(col, 1); }
+
+	//! \~english Removes all rows that satisfy a condition.
+	//! \~russian Удаляет все строки, удовлетворяющие условию.
+	//! \details
+	//! \~english Rows are removed from the bottom to avoid index shifting issues.
+	//! \~russian Строки удаляются снизу вверх, чтобы избежать проблем со смещением индексов.
+	//! \~\sa removeColumnsWhere(), PIVector::removeWhere()
+	inline PIVector2D<T> & removeRowsWhere(std::function<bool(const RowConst &)> test) {
+		ssize_t r = rows_;
+		while (--r >= 0) {
+			if (test(RowConst(this, r))) {
+				removeRow(r);
+			}
+		}
+		return *this;
+	}
+
+	//! \~english Removes all columns that satisfy a condition.
+	//! \~russian Удаляет все столбцы, удовлетворяющие условию.
+	//! \~\sa removeRowsWhere()
+	inline PIVector2D<T> & removeColumnsWhere(std::function<bool(const ColConst &)> test) {
+		ssize_t c = cols_;
+		while (--c >= 0) {
+			if (test(ColConst(this, c))) {
+				removeColumn(c);
+			}
+		}
+		return *this;
+	}
+
+
+	//! \~english Returns a new 2D array containing only the rows that pass the test.
+	//! \~russian Возвращает новый двумерный массив, содержащий только строки, прошедшие проверку.
+	//! \~\sa filterColumns(), PIVector::filter()
+	inline PIVector2D<T> filterRows(std::function<bool(const RowConst &)> test) const {
+		PIVector2D<T> result;
+		for (size_t r = 0; r < rows_; ++r) {
+			RowConst currentRow = row(r);
+			if (test(currentRow)) {
+				result.addRow(currentRow);
+			}
+		}
+		return result;
+	}
+
+	//! \~english Returns a new 2D array containing only the columns that pass the test.
+	//! \~russian Возвращает новый двумерный массив, содержащий только столбцы, прошедшие проверку.
+	//! \~\sa filterRows()
+	inline PIVector2D<T> filterColumns(std::function<bool(const ColConst &)> test) const {
+		if (isEmpty()) return PIVector2D<T>();
+		PIVector<size_t> goodCols;
+		for (size_t c = 0; c < cols_; ++c) {
+			if (test(col(c))) {
+				goodCols << c;
+			}
+		}
+		PIVector2D<T> result;
+		for (size_t gc = 0; gc < goodCols.size(); ++gc) {
+			result.addColumn(col(goodCols[gc]));
+		}
+		return result;
+	}
+
 protected:
 	size_t rows_, cols_;
 	PIVector<T> mat;
 };
 
 
+//! \relatesalso PICout
+//! \~english Output operator for \a PIVector2D to \a PICout.
+//! \~russian Оператор вывода \a PIVector2D в \a PICout.
 template<typename T>
 inline PICout operator<<(PICout s, const PIVector2D<T> & v) {
 	s.saveAndSetControls(0);
@@ -346,5 +1399,6 @@ inline PICout operator<<(PICout s, const PIVector2D<T> & v) {
 	return s;
 }
 
+//! \}
 
 #endif // PIVECTOR2D_H

libs/main/core/piobject.cpp

@@ -21,7 +21,6 @@
 
 #include "piconditionvar.h"
 #include "pithread.h"
-#include "pitime.h"
 #ifndef MICRO_PIP
 #  include "pifile.h"
 #  include "piiostream.h"

libs/main/core/piwaitevent_p.cpp

@@ -18,19 +18,18 @@
 */
 
 #include "piwaitevent_p.h"
-#ifndef MICRO_PIP
-#  ifdef WINDOWS
+#ifdef WINDOWS
 // #  ifdef _WIN32_WINNT
 // #    undef _WIN32_WINNT
 // #    define _WIN32_WINNT 0x0600
 // #  endif
-#	include <synchapi.h>
-#  else
-#	include <errno.h>
-#	include <fcntl.h>
-#	include <sys/ioctl.h>
-#  endif
-#  include "pistring.h"
+#  include <synchapi.h>
+#else
+#  include <errno.h>
+#  include <fcntl.h>
+#  include <sys/ioctl.h>
+#endif
+#include "pistring.h"
 
 
 PIWaitEvent::~PIWaitEvent() {
@@ -40,12 +39,12 @@ PIWaitEvent::~PIWaitEvent() {
 
 void PIWaitEvent::create() {
 	destroy();
-#  ifdef WINDOWS
+#ifdef WINDOWS
 	event = CreateEventA(NULL, TRUE, FALSE, NULL);
 	if (!event) {
 		piCout << "Error with CreateEventA:" << errorString();
 	}
-#  else
+#else
 	for (int i = 0; i < 3; ++i)
 		piZeroMemory(fds[i]);
 	if (::pipe(pipe_fd) < 0) {
@@ -54,34 +53,34 @@ void PIWaitEvent::create() {
 		fcntl(pipe_fd[ReadEnd], F_SETFL, O_NONBLOCK);
 		fcntl(pipe_fd[WriteEnd], F_SETFL, O_NONBLOCK);
 	}
-#  endif
+#endif
 }
 
 
 void PIWaitEvent::destroy() {
-#  ifdef WINDOWS
+#ifdef WINDOWS
 	if (event) {
 		CloseHandle(event);
 		event = NULL;
 	}
-#  else
+#else
 	for (int i = 0; i < 2; ++i) {
 		if (pipe_fd[i] != 0) {
 			::close(pipe_fd[i]);
 			pipe_fd[i] = 0;
 		}
 	}
-#  endif
+#endif
 }
 
 
 bool PIWaitEvent::wait(int fd, CheckRole role) {
 	if (!isCreate()) return false;
-#  ifdef WINDOWS
+#ifdef WINDOWS
 	DWORD ret = WaitForSingleObjectEx(event, INFINITE, TRUE);
 	ResetEvent(event);
 	if (ret == WAIT_IO_COMPLETION || ret == WAIT_FAILED) return false;
-#  else
+#else
 	if (fd == -1) return false;
 	int nfds     = piMaxi(pipe_fd[ReadEnd], fd) + 1;
 	int fd_index = role;
@@ -98,18 +97,18 @@ bool PIWaitEvent::wait(int fd, CheckRole role) {
 	if (sr == EBADF || sr == EINTR) return false;
 	if (FD_ISSET(fd, &(fds[CheckExeption]))) return true;
 	return FD_ISSET(fd, &(fds[fd_index]));
-#  endif
+#endif
 	return true;
 }
 
 
 bool PIWaitEvent::sleep(int us) {
 	if (!isCreate()) return false;
-#  ifdef WINDOWS
+#ifdef WINDOWS
 	DWORD ret = WaitForSingleObjectEx(event, us / 1000, TRUE);
 	ResetEvent(event);
 	return ret == WAIT_TIMEOUT;
-#  else
+#else
 	int nfds = pipe_fd[ReadEnd] + 1;
 	FD_ZERO(&(fds[CheckRead]));
 	FD_SET(pipe_fd[ReadEnd], &(fds[CheckRead]));
@@ -121,36 +120,34 @@ bool PIWaitEvent::sleep(int us) {
 	while (::read(pipe_fd[ReadEnd], &buf, sizeof(buf)) > 0)
 		;
 	return ret == 0;
-#  endif
+#endif
 }
 
 
 void PIWaitEvent::interrupt() {
 	if (!isCreate()) return;
-#  ifdef WINDOWS
+#ifdef WINDOWS
 	SetEvent(event);
-#  else
+#else
 	auto _r = ::write(pipe_fd[WriteEnd], "", 1);
 	NO_UNUSED(_r);
-#  endif
+#endif
 }
 
 
 bool PIWaitEvent::isCreate() const {
-#  ifdef WINDOWS
+#ifdef WINDOWS
 	return event;
-#  else
+#else
 	return pipe_fd[ReadEnd] != 0;
-#  endif
+#endif
 }
 
 
 void * PIWaitEvent::getEvent() const {
-#  ifdef WINDOWS
+#ifdef WINDOWS
 	return event;
-#  else
+#else
 	return nullptr;
-#  endif
+#endif
 }
-
-#endif // MICRO_PIP

libs/main/core/piwaitevent_p.h

@@ -20,9 +20,7 @@
 #ifndef PIWAITEVENT_P_H
 #define PIWAITEVENT_P_H
 
-#ifndef MICRO_PIP
-
-#  include "pibase.h"
+#include "pibase.h"
 // clang-format off
 #ifdef WINDOWS
 #  include <stdarg.h>
@@ -54,18 +52,17 @@ public:
 	void * getEvent() const; // WINDOWS only
 
 private:
-#  ifdef WINDOWS
+#ifdef WINDOWS
 	void * event = nullptr;
-#  else
+#else
 	int pipe_fd[2] = {0, 0};
 	fd_set fds[3];
 	enum {
 		ReadEnd  = 0,
 		WriteEnd = 1
 	};
-#  endif
+#endif
 };
 
 
-#endif // MICRO_PIP
 #endif // PIWAITEVENT_P_H

libs/main/introspection/piintrospection_server_p.cpp

@@ -19,12 +19,10 @@
 
 #include "piintrospection_server_p.h"
 
-#if defined(PIP_INTROSPECTION) && !defined(PIP_FORCE_NO_PIINTROSPECTION)
-
-#  include "pichunkstream.h"
-#  include "piinit.h"
-#  include "piobject.h"
-#  include "pisysteminfo.h"
+#include "pichunkstream.h"
+#include "piinit.h"
+#include "piobject.h"
+#include "pisysteminfo.h"
 
 
 const uint PIIntrospection::sign = 0x0F1C2B3A;
@@ -113,9 +111,9 @@ PIByteArray PIIntrospection::packContainers() {
 	PIByteArray ret;
 	PIVector<PIIntrospectionContainers::TypeInfo> data;
 	PIIntrospectionContainers * p = 0;
-#  ifdef PIP_INTROSPECTION
+#ifdef PIP_INTROSPECTION
 	p = PIINTROSPECTION_CONTAINERS->p;
-#  endif
+#endif
 	if (p) {
 		data = p->getInfo();
 	}
@@ -133,9 +131,9 @@ void PIIntrospection::unpackContainers(PIByteArray & ba, PIVector<PIIntrospectio
 PIByteArray PIIntrospection::packThreads() {
 	PIByteArray ret;
 	PIIntrospectionThreads * p = 0;
-#  ifdef PIP_INTROSPECTION
+#ifdef PIP_INTROSPECTION
 	p = PIINTROSPECTION_THREADS->p;
-#  endif
+#endif
 	if (p) {
 		p->mutex.lock();
 		PIMap<PIThread *, PIIntrospectionThreads::ThreadInfo> & tm(p->threads);
@@ -172,5 +170,3 @@ void PIIntrospection::unpackObjects(PIByteArray & ba, PIVector<PIIntrospection::
 	objects.clear();
 	ba >> objects;
 }
-
-#endif // #if defined(PIP_INTROSPECTION) && !defined(PIP_FORCE_NO_PIINTROSPECTION)

libs/main/introspection/piintrospection_server_p.h

@@ -27,7 +27,6 @@
 #include "piintrospection_threads_p.h"
 #include "pisystemmonitor.h"
 
-#if defined(PIP_INTROSPECTION) && !defined(PIP_FORCE_NO_PIINTROSPECTION)
 
 class PIP_EXPORT PIIntrospection {
 public:
@@ -169,5 +168,4 @@ BINARY_STREAM_READ(PIIntrospection::ObjectInfo) {
 	return s;
 }
 
-#endif // #if defined(PIP_INTROSPECTION) && !defined(PIP_FORCE_NO_PIINTROSPECTION)
 #endif // PIINTROSPECTION_SERVER_P_H

libs/main/introspection/piintrospection_threads_p.cpp

@@ -19,7 +19,6 @@
 
 #include "piintrospection_threads_p.h"
 
-#if defined(PIP_INTROSPECTION) && !defined(PIP_FORCE_NO_PIINTROSPECTION)
 
 PIIntrospectionThreads::ThreadInfo::ThreadInfo() {
 	id = delay = 0;
@@ -79,5 +78,3 @@ void PIIntrospectionThreads::threadRunDone(PIThread * t, ullong us) {
 	ThreadInfo & ti(threads[t]);
 	ti.run_us = (ti.run_us * 0.8) + (us * 0.2); /// WARNING
 }
-
-#endif // #if defined(PIP_INTROSPECTION) && !defined(PIP_FORCE_NO_PIINTROSPECTION)

libs/main/introspection/piintrospection_threads_p.h

@@ -20,10 +20,6 @@
 #ifndef PIINTROSPECTION_THREADS_P_H
 #define PIINTROSPECTION_THREADS_P_H
 
-#include "pibase.h"
-
-#if defined(PIP_INTROSPECTION) && !defined(PIP_FORCE_NO_PIINTROSPECTION)
-
 #include "pimap.h"
 #include "pithread.h"
 
@@ -72,5 +68,4 @@ BINARY_STREAM_READ(PIIntrospectionThreads::ThreadInfo) {
 	return s;
 }
 
-#endif // #if defined(PIP_INTROSPECTION) && !defined(PIP_FORCE_NO_PIINTROSPECTION)
 #endif // PIINTROSPECTION_THREADS_P_H

libs/main/io_devices/pican.cpp

@@ -20,7 +20,7 @@
 
 #include "pipropertystorage.h"
 #include "piwaitevent_p.h"
-#if !defined(WINDOWS) && !defined(MAC_OS) && !defined(PIP_NO_SOCKET)
+#if !defined(WINDOWS) && !defined(MAC_OS) && !defined(MICRO_PIP)
 #  define PIP_CAN
 #endif
 #ifdef PIP_CAN
@@ -39,29 +39,25 @@
 
 REGISTER_DEVICE(PICAN)
 
-#ifdef PIP_CAN
+
 PRIVATE_DEFINITION_START(PICAN)
 	PIWaitEvent event;
 PRIVATE_DEFINITION_END(PICAN)
-#endif
+
 
 PICAN::PICAN(const PIString & path, PIIODevice::DeviceMode mode): PIIODevice(path, mode) {
 	setThreadedReadBufferSize(256);
 	setPath(path);
-#ifdef PIP_CAN
 	can_id = 0;
 	sock   = 0;
 	PRIVATE->event.create();
-#endif
 }
 
 
 PICAN::~PICAN() {
 	stopAndWait();
 	close();
-#ifdef PIP_CAN
 	PRIVATE->event.destroy();
-#endif
 }
 
 
@@ -168,9 +164,7 @@ int PICAN::readedCANID() const {
 
 
 void PICAN::interrupt() {
-#ifdef PIP_CAN
 	PRIVATE->event.interrupt();
-#endif
 }
 
 

libs/main/io_devices/piethernet.cpp

@@ -18,65 +18,64 @@
 */
 #include "piethernet.h"
 
-#ifndef PIP_NO_SOCKET
-
-#  include "piconfig.h"
-#  include "piconstchars.h"
-#  include "piincludes_p.h"
-#  include "piliterals.h"
-#  include "pipropertystorage.h"
-#  include "pisysteminfo.h"
-#  include "pitranslator.h"
-
-#  ifdef QNX
-#	include <arpa/inet.h>
-#	include <fcntl.h>
-#	include <hw/nicinfo.h>
-#	include <ifaddrs.h>
-#	include <net/if.h>
-#	include <net/if_dl.h>
-#	include <netdb.h>
+#include "piconfig.h"
+#include "piconstchars.h"
+#include "piincludes_p.h"
+#include "piliterals.h"
+#include "pipropertystorage.h"
+#include "pisysteminfo.h"
+#include "pitranslator.h"
+// clang-format off
+#ifdef QNX
+#  include <arpa/inet.h>
+#  include <fcntl.h>
+#  include <hw/nicinfo.h>
+#  include <ifaddrs.h>
+#  include <net/if.h>
+#  include <net/if_dl.h>
+#  include <netdb.h>
+#  include <netinet/in.h>
+#  include <sys/ioctl.h>
+#  include <sys/socket.h>
+#  include <sys/time.h>
+#  include <sys/types.h>
+#  ifdef BLACKBERRY
 #	include <netinet/in.h>
-#	include <sys/ioctl.h>
-#	include <sys/socket.h>
-#	include <sys/time.h>
-#	include <sys/types.h>
-#	ifdef BLACKBERRY
-#	  include <netinet/in.h>
-#	else
-#	  include <sys/dcmd_io-net.h>
-#	endif
-#	define ip_mreqn    ip_mreq
-#	define imr_address imr_interface
 #  else
-#	ifdef WINDOWS
-#	  include <io.h>
-#	  include <iphlpapi.h>
-#	  include <psapi.h>
-#	  include <winsock2.h>
-#	  include <ws2tcpip.h>
-#	  define ip_mreqn    ip_mreq
-#	  define imr_address imr_interface
-#	else
-#	  include <arpa/inet.h>
-#	  include <fcntl.h>
-#	  include <net/if.h>
-#	  include <netdb.h>
-#	  include <netinet/in.h>
-#	  include <netinet/tcp.h>
-#	  include <sys/ioctl.h>
-#	  include <sys/socket.h>
-#	  if !defined(ANDROID) && !defined(LWIP)
-#		include <ifaddrs.h>
-#	  endif
-#	  ifdef LWIP
-#		include <lwip/sockets.h>
-#	  endif
-#	endif
+#	include <sys/dcmd_io-net.h>
 #  endif
-#  include "piwaitevent_p.h"
+#  define ip_mreqn    ip_mreq
+#  define imr_address imr_interface
+#else
+#  ifdef WINDOWS
+#    include <io.h>
+#    include <winsock2.h>
+#    include <iphlpapi.h>
+#    include <psapi.h>
+#    include <ws2tcpip.h>
+#    define ip_mreqn ip_mreq
+#    define imr_address imr_interface
+#  else
+#    include <fcntl.h>
+#    include <sys/ioctl.h>
+#    include <netinet/in.h>
+#    include <netinet/tcp.h>
+#    include <arpa/inet.h>
+#    include <sys/socket.h>
+#    include <netdb.h>
+#    include <net/if.h>
+#    if !defined(ANDROID) && !defined(LWIP)
+#      include <ifaddrs.h>
+#    endif
+#    ifdef LWIP
+#      include <lwip/sockets.h>
+#    endif
+#  endif
+#endif
+// clang-format on
+#include "piwaitevent_p.h"
 
-#  include <errno.h>
+#include <errno.h>
 
 
 /** \class PIEthernet piethernet.h
@@ -101,11 +100,11 @@
  *
  * */
 
-#  ifndef WINDOWS
+#ifndef WINDOWS
 PIString getSockAddr(sockaddr * s) {
 	return s == 0 ? PIString() : PIStringAscii(inet_ntoa(((sockaddr_in *)s)->sin_addr));
 }
-#  endif
+#endif
 
 
 REGISTER_DEVICE(PIEthernet)
@@ -197,11 +196,11 @@ void PIEthernet::construct() {
 	setMulticastTTL(1);
 	server_thread_.setData(this);
 	server_thread_.setName("_S.tcpserver"_a);
-#  ifdef LWIP
+#ifdef MICRO_PIP
 	setThreadedReadBufferSize(512);
-#  else
+#else
 	setThreadedReadBufferSize(64_KiB);
-#  endif
+#endif
 	// setPriority(piHigh);
 }
 
@@ -305,9 +304,9 @@ bool PIEthernet::openDevice() {
 		PRIVATE->addr_.sin_addr.s_addr = INADDR_ANY;
 	else
 		PRIVATE->addr_.sin_addr.s_addr = addr_r.ip();
-#  ifdef QNX
+#ifdef QNX
 	PRIVATE->addr_.sin_len = sizeof(PRIVATE->addr_);
-#  endif
+#endif
 	// piCout << "bind to" << (params[PIEthernet::Broadcast] ? "255.255.255.255" : ip_) << ":" << port_ << " ...";
 	int tries = 0;
 	while ((bind(sock, (sockaddr *)&PRIVATE->addr_, sizeof(PRIVATE->addr_)) == -1) && (tries < 2)) {
@@ -380,14 +379,14 @@ void PIEthernet::applyBuffers() {
 
 void PIEthernet::applyTimeout(int fd, int opt, PISystemTime tm) {
 	if (fd == 0) return;
-		// piCoutObj << "setReadIsBlocking" << yes;
-#  ifdef WINDOWS
+	// piCoutObj << "setReadIsBlocking" << yes;
+#ifdef WINDOWS
 	DWORD _tm = tm.toMilliseconds();
-#  else
+#else
 	timeval _tm;
 	_tm.tv_sec  = tm.seconds;
 	_tm.tv_usec = tm.nanoseconds / 1000;
-#  endif
+#endif
 	ethSetsockopt(fd, SOL_SOCKET, opt, &_tm, sizeof(_tm));
 }
 
@@ -412,30 +411,30 @@ bool PIEthernet::joinMulticastGroup(const PIString & group) {
 		return true;
 	}
 	addr_r.set(path());
-#  ifndef LWIP
+#ifndef LWIP
 	struct ip_mreqn mreq;
-#  else
+#else
 	struct ip_mreq mreq;
-#  endif
+#endif
 	piZeroMemory(mreq);
-#  ifdef LINUX
+#ifdef LINUX
 	// mreq.imr_address.s_addr = INADDR_ANY;
 	/*PIEthernet::InterfaceList il = interfaces();
 	const PIEthernet::Interface * ci = il.getByAddress(addr_r.ipString());
 	if (ci != 0) mreq.imr_ifindex = ci->index;*/
-#  endif
+#endif
 	if (params[PIEthernet::Broadcast])
-#  ifndef LWIP
+#ifndef LWIP
 		mreq.imr_address.s_addr = INADDR_ANY;
-#  else
+#else
 		mreq.imr_interface.s_addr = INADDR_ANY;
-#  endif
+#endif
 	else
-#  ifndef LWIP
+#ifndef LWIP
 		mreq.imr_address.s_addr = addr_r.ip();
-#  else
+#else
 		mreq.imr_interface.s_addr = addr_r.ip();
-#  endif
+#endif
 
 	// piCout << "join group" << group << "ip" << ip_ << "with index" << mreq.imr_ifindex << "socket" << sock;
 	mreq.imr_multiaddr.s_addr = inet_addr(group.dataAscii());
@@ -458,24 +457,24 @@ bool PIEthernet::leaveMulticastGroup(const PIString & group) {
 		return false;
 	}
 	addr_r.set(path());
-#  ifndef LWIP
+#ifndef LWIP
 	struct ip_mreqn mreq;
-#  else
+#else
 	struct ip_mreq mreq;
-#  endif
+#endif
 	piZeroMemory(mreq);
 	if (params[PIEthernet::Broadcast])
-#  ifndef LWIP
+#ifndef LWIP
 		mreq.imr_address.s_addr = INADDR_ANY;
-#  else
+#else
 		mreq.imr_interface.s_addr = INADDR_ANY;
-#  endif
+#endif
 	else
-#  ifndef LWIP
+#ifndef LWIP
 		mreq.imr_address.s_addr = addr_r.ip();
-#  else
+#else
 		mreq.imr_interface.s_addr = addr_r.ip();
-#  endif
+#endif
 	mreq.imr_multiaddr.s_addr = inet_addr(group.dataAscii());
 	if (ethSetsockopt(sock, IPPROTO_IP, IP_DROP_MEMBERSHIP, &mreq, sizeof(mreq)) == -1) {
 		piCoutObj << "Can`t leave multicast group" << group << "," << ethErrorString();
@@ -499,9 +498,9 @@ bool PIEthernet::connect(bool threaded) {
 	PRIVATE->addr_.sin_port        = htons(addr_r.port());
 	PRIVATE->addr_.sin_addr.s_addr = addr_r.ip();
 	PRIVATE->addr_.sin_family      = AF_INET;
-#  ifdef QNX
+#ifdef QNX
 	PRIVATE->addr_.sin_len = sizeof(PRIVATE->addr_);
-#  endif
+#endif
 	connecting_ = true;
 	connected_  = connectTCP();
 	connecting_ = false;
@@ -536,9 +535,9 @@ bool PIEthernet::listen(bool threaded) {
 	PRIVATE->addr_.sin_port        = htons(addr_r.port());
 	PRIVATE->addr_.sin_addr.s_addr = addr_r.ip();
 	PRIVATE->addr_.sin_family      = AF_INET;
-#  ifdef QNX
+#ifdef QNX
 	PRIVATE->addr_.sin_len = sizeof(PRIVATE->addr_);
-#  endif
+#endif
 	opened_   = false;
 	int tries = 0;
 	while ((bind(sock, (sockaddr *)&PRIVATE->addr_, sizeof(PRIVATE->addr_)) == -1) && (tries < 2)) {
@@ -662,9 +661,9 @@ ssize_t PIEthernet::readDevice(void * read_to, ssize_t max_size) {
 			PRIVATE->addr_.sin_port        = htons(addr_r.port());
 			PRIVATE->addr_.sin_addr.s_addr = addr_r.ip();
 			PRIVATE->addr_.sin_family      = AF_INET;
-#  ifdef QNX
+#ifdef QNX
 			PRIVATE->addr_.sin_len = sizeof(PRIVATE->addr_);
-#  endif
+#endif
 			// piCoutObj << "connect to " << path() << "...";
 			connected_ = connectTCP();
 			// piCoutObj << "connect to " << path() << connected_;
@@ -679,7 +678,7 @@ ssize_t PIEthernet::readDevice(void * read_to, ssize_t max_size) {
 		}
 		if (!connected_) return -1;
 		errorClear();
-#  ifdef WINDOWS
+#ifdef WINDOWS
 		{
 			long wr = waitForEvent(PRIVATE->event, FD_READ | FD_CLOSE);
 			switch (wr) {
@@ -695,34 +694,34 @@ ssize_t PIEthernet::readDevice(void * read_to, ssize_t max_size) {
 			default: break;
 			}
 		}
-#  else
+#else
 		if (PRIVATE->event.wait(sock)) {
 			errorClear();
 			rs = ethRecv(sock, read_to, max_size);
 		}
-#  endif
+#endif
 		// piCoutObj << "readed" << rs;
 		if (rs <= 0) {
 			lerr = ethErrorCore();
 			// piCoutObj << "readed" << rs << "error" << lerr;
 
 			// async normal returns
-#  ifdef WINDOWS
+#ifdef WINDOWS
 			if (lerr == WSAEWOULDBLOCK) {
-#  else
+#else
 			if (lerr == EWOULDBLOCK || lerr == EAGAIN || lerr == EINTR) {
-#  endif
+#endif
 				// piCoutObj << "Ignore would_block" << lerr;
 				return -1;
 			}
 
 			// if no disconnect on timeout
 			if (!params[DisonnectOnTimeout]) {
-#  ifdef WINDOWS
+#ifdef WINDOWS
 				if (lerr == WSAETIMEDOUT) {
-#  else
+#else
 				if (lerr == ETIMEDOUT) {
-#  endif
+#endif
 					// piCoutObj << "Ignore read timeout";
 					return -1;
 				}
@@ -746,7 +745,7 @@ ssize_t PIEthernet::readDevice(void * read_to, ssize_t max_size) {
 	case UDP: {
 		piZeroMemory(PRIVATE->raddr_);
 		// piCoutObj << "read from" << path() << "...";
-#  ifdef WINDOWS
+#ifdef WINDOWS
 		long wr = waitForEvent(PRIVATE->event, FD_READ | FD_CLOSE);
 		switch (wr) {
 		case FD_READ:
@@ -759,9 +758,9 @@ ssize_t PIEthernet::readDevice(void * read_to, ssize_t max_size) {
 			break;
 		default: break;
 		}
-#  else
+#else
 		rs = ethRecvfrom(sock, read_to, max_size, 0, (sockaddr *)&PRIVATE->raddr_);
-#  endif
+#endif
 		// piCoutObj << "read from" << path() << rs << "bytes";
 		if (rs > 0) {
 			addr_lr.set(uint(PRIVATE->raddr_.sin_addr.s_addr), ntohs(PRIVATE->raddr_.sin_port));
@@ -794,11 +793,11 @@ ssize_t PIEthernet::writeDevice(const void * data, ssize_t max_size) {
 		return ethSendto(sock_s,
 		                 data,
 		                 max_size,
-#  ifndef WINDOWS
+#ifndef WINDOWS
 		                 isOptionSet(BlockingWrite) ? 0 : MSG_DONTWAIT
-#  else
+#else
 		                 0
-#  endif
+#endif
 		                 ,
 		                 (sockaddr *)&PRIVATE->saddr_,
 		                 sizeof(PRIVATE->saddr_));
@@ -810,9 +809,9 @@ ssize_t PIEthernet::writeDevice(const void * data, ssize_t max_size) {
 			PRIVATE->addr_.sin_port        = htons(addr_r.port());
 			PRIVATE->addr_.sin_addr.s_addr = addr_r.ip();
 			PRIVATE->addr_.sin_family      = AF_INET;
-#  ifdef QNX
+#ifdef QNX
 			PRIVATE->addr_.sin_len = sizeof(PRIVATE->addr_);
-#  endif
+#endif
 			// piCoutObj << "connect to " << ip << ":" << port_;
 			connected_ = connectTCP();
 			if (!connected_) piCoutObj << "Can`t connect to" << addr_r << "," << ethErrorString();
@@ -848,11 +847,11 @@ ssize_t PIEthernet::writeDevice(const void * data, ssize_t max_size) {
 				int sr = ::send(sock, remain_data, remain_size, 0);
 				if (sr < 0) {
 					int err = ethErrorCore();
-#  ifdef WINDOWS
+#ifdef WINDOWS
 					if (err == WSAEWOULDBLOCK) {
-#  else
+#else
 					if (err == EAGAIN || err == EWOULDBLOCK) {
-#  endif
+#endif
 						piMinSleep();
 						// piCoutObj << "wait for write";
 						continue;
@@ -911,30 +910,30 @@ void PIEthernet::server_func(void * eth) {
 	}
 	sockaddr_in client_addr;
 	socklen_t slen = sizeof(client_addr);
-#  ifdef WINDOWS
+#ifdef WINDOWS
 	long wr = ce->waitForEvent(ce->PRIVATEWB->event, FD_ACCEPT | FD_CLOSE);
 	if (wr != FD_ACCEPT) {
 		piMSleep(10);
 		return;
 	}
-#  else
+#else
 	if (!ce->PRIVATEWB->event.wait(ce->sock)) {
 		piMSleep(10);
 		return;
 	}
-#  endif
+#endif
 	// piCout << "server" << "accept ...";
 	int s = accept(ce->sock, (sockaddr *)&client_addr, &slen);
 	// piCout << "server" << "accept done" << ethErrorString();
 	if (s == -1) {
 		int lerr = ethErrorCore();
-#  ifdef WINDOWS
+#ifdef WINDOWS
 		if (lerr == WSAETIMEDOUT) {
-#  elif defined(ANDROID)
+#elif defined(ANDROID)
 		if ((lerr == EAGAIN || lerr == EINTR)) {
-#  else
+#else
 		if (lerr == EAGAIN) {
-#  endif
+#endif
 			piMSleep(10);
 			return;
 		}
@@ -970,7 +969,7 @@ void PIEthernet::setType(Type t, bool reopen) {
 bool PIEthernet::connectTCP() {
 	::connect(sock, (sockaddr *)&(PRIVATE->addr_), sizeof(PRIVATE->addr_));
 	// piCout << errorString();
-#  ifdef WINDOWS
+#ifdef WINDOWS
 	long wr = waitForEvent(PRIVATE->event, FD_CONNECT | FD_CLOSE);
 	switch (wr) {
 	case FD_CONNECT:
@@ -978,7 +977,7 @@ bool PIEthernet::connectTCP() {
 		return ethIsWriteable(sock);
 	default: break;
 	}
-#  else
+#else
 	if (PRIVATE->event.wait(sock, PIWaitEvent::CheckWrite)) {
 		if (ethIsWriteable(sock))
 			return true;
@@ -987,12 +986,12 @@ bool PIEthernet::connectTCP() {
 			init();
 		}
 	}
-#  endif
+#endif
 	return false;
 }
 
 
-#  ifdef WINDOWS
+#ifdef WINDOWS
 long PIEthernet::waitForEvent(PIWaitEvent & event, long mask) {
 	if (!event.isCreate() || sock < 0) return 0;
 	if (WSAEventSelect(sock, event.getEvent(), mask) == SOCKET_ERROR) {
@@ -1009,7 +1008,7 @@ long PIEthernet::waitForEvent(PIWaitEvent & event, long mask) {
 	}
 	return 0;
 }
-#  endif
+#endif
 
 
 bool PIEthernet::configureDevice(const void * e_main, const void * e_parent) {
@@ -1119,7 +1118,7 @@ PIEthernet::InterfaceList PIEthernet::interfaces() {
 	Interface ci;
 	ci.index = -1;
 	ci.mtu   = 1500;
-#  ifdef WINDOWS
+#ifdef WINDOWS
 	int ret                       = 0;
 	ulong ulOutBufLen             = sizeof(IP_ADAPTER_INFO);
 	PIP_ADAPTER_INFO pAdapterInfo = (PIP_ADAPTER_INFO)HeapAlloc(GetProcessHeap(), 0, sizeof(IP_ADAPTER_INFO));
@@ -1170,10 +1169,10 @@ PIEthernet::InterfaceList PIEthernet::interfaces() {
 		}
 	}
 	if (pAdapterInfo) HeapFree(GetProcessHeap(), 0, pAdapterInfo);
+#else
+#  ifdef MICRO_PIP
 #  else
-#	ifdef LWIP
-#	else
-#	  ifdef ANDROID
+#	ifdef ANDROID
 	struct ifconf ifc;
 	int s       = ::socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
 	ifc.ifc_len = 256;
@@ -1201,7 +1200,7 @@ PIEthernet::InterfaceList PIEthernet::interfaces() {
 		il << ci;
 	}
 	delete ifc.ifc_buf;
-#	  else
+#	else
 	struct ifaddrs *ret, *cif = 0;
 	int s = ::socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
 	if (getifaddrs(&ret) == 0) {
@@ -1219,8 +1218,8 @@ PIEthernet::InterfaceList PIEthernet::interfaces() {
 			ci.address = getSockAddr(cif->ifa_addr);
 			ci.netmask = getSockAddr(cif->ifa_netmask);
 			ci.mac.clear();
-#		ifdef QNX
-#		  ifndef BLACKBERRY
+#	  ifdef QNX
+#		ifndef BLACKBERRY
 			int fd = ::open((PIString("/dev/io-net/") + ci.name).dataAscii(), O_RDONLY);
 			if (fd != 0) {
 				nic_config_t nic;
@@ -1228,9 +1227,9 @@ PIEthernet::InterfaceList PIEthernet::interfaces() {
 				::close(fd);
 				ci.mac = macFromBytes(PIByteArray(nic.permanent_address, 6));
 			}
-#		  endif
-#		else
-#		  ifdef MAC_OS
+#		endif
+#	  else
+#		ifdef MAC_OS
 			PIString req = PISystemInfo::instance()->ifconfigPath + " " + ci.name + " | grep ether";
 			FILE * fp    = popen(req.dataAscii(), "r");
 			if (fp != 0) {
@@ -1241,7 +1240,7 @@ PIEthernet::InterfaceList PIEthernet::interfaces() {
 				}
 				pclose(fp);
 			}
-#		  else
+#		else
 			if (s != -1) {
 				struct ifreq ir;
 				memset(&ir, 0, sizeof(ir));
@@ -1253,8 +1252,8 @@ PIEthernet::InterfaceList PIEthernet::interfaces() {
 					ci.mtu = ir.ifr_mtu;
 				}
 			}
-#		  endif
 #		endif
+#	  endif
 			ci.flags = 0;
 			if (cif->ifa_flags & IFF_UP) ci.flags |= PIEthernet::ifActive;
 			if (cif->ifa_flags & IFF_RUNNING) ci.flags |= PIEthernet::ifRunning;
@@ -1275,18 +1274,18 @@ PIEthernet::InterfaceList PIEthernet::interfaces() {
 		piCout << "[PIEthernet]"
 			   << "Can`t get interfaces: %1"_tr("PIEthernet").arg(errorString());
 	if (s != -1) ::close(s);
-#	  endif
 #	endif
 #  endif
+#endif
 	return il;
 }
 
 
 PINetworkAddress PIEthernet::interfaceAddress(const PIString & interface_) {
-#  if defined(WINDOWS) || defined(LWIP)
+#if defined(WINDOWS) || defined(MICRO_PIP)
 	piCout << "[PIEthernet] Not implemented, use \"PIEthernet::allAddresses\" or \"PIEthernet::interfaces\" instead";
 	return PINetworkAddress();
-#  else
+#else
 	struct ifreq ifr;
 	piZeroMemory(ifr);
 	strcpy(ifr.ifr_name, interface_.dataAscii());
@@ -1295,7 +1294,7 @@ PINetworkAddress PIEthernet::interfaceAddress(const PIString & interface_) {
 	::close(s);
 	struct sockaddr_in * sa = (struct sockaddr_in *)&ifr.ifr_addr;
 	return PINetworkAddress(uint(sa->sin_addr.s_addr));
-#  endif
+#endif
 }
 
 
@@ -1318,16 +1317,16 @@ PIVector<PINetworkAddress> PIEthernet::allAddresses() {
 // System wrap
 
 int PIEthernet::ethErrorCore() {
-#  ifdef WINDOWS
+#ifdef WINDOWS
 	return WSAGetLastError();
-#  else
+#else
 	return errno;
-#  endif
+#endif
 }
 
 
 PIString PIEthernet::ethErrorString() {
-#  ifdef WINDOWS
+#ifdef WINDOWS
 	char * msg = nullptr;
 	int err    = WSAGetLastError();
 	FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
@@ -1344,18 +1343,18 @@ PIString PIEthernet::ethErrorString() {
 	} else
 		ret += '?';
 	return ret;
-#  else
+#else
 	return errorString();
-#  endif
+#endif
 }
 
 
 int PIEthernet::ethRecv(int sock, void * buf, int size, int flags) {
 	if (sock < 0) return -1;
 	return recv(sock,
-#  ifdef WINDOWS
+#ifdef WINDOWS
 	            (char *)
-#  endif
+#endif
 	                buf,
 	            size,
 	            flags);
@@ -1364,29 +1363,29 @@ int PIEthernet::ethRecv(int sock, void * buf, int size, int flags) {
 
 int PIEthernet::ethRecvfrom(int sock, void * buf, int size, int flags, sockaddr * addr) {
 	if (sock < 0) return -1;
-#  ifdef QNX
+#ifdef QNX
 	return recv(sock, buf, size, flags);
-#  else
+#else
 	socklen_t len = sizeof(sockaddr);
 	return recvfrom(sock,
-#	ifdef WINDOWS
+#  ifdef WINDOWS
 	                (char *)
-#	endif
+#  endif
 	                    buf,
 	                size,
 	                flags,
 	                addr,
 	                &len);
-#  endif
+#endif
 }
 
 
 int PIEthernet::ethSendto(int sock, const void * buf, int size, int flags, sockaddr * addr, int addr_len) {
 	if (sock < 0) return -1;
 	return sendto(sock,
-#  ifdef WINDOWS
+#ifdef WINDOWS
 	              (const char *)
-#  endif
+#endif
 	                  buf,
 	              size,
 	              flags,
@@ -1400,26 +1399,26 @@ void PIEthernet::ethClosesocket(int sock, bool shutdown) {
 	if (sock < 0) return;
 	if (shutdown)
 		::shutdown(sock,
-#  ifdef WINDOWS
+#ifdef WINDOWS
 		           SD_BOTH);
 	closesocket(sock);
-#  else
+#else
 		           SHUT_RDWR);
 	::close(sock);
-#  endif
+#endif
 }
 
 
 int PIEthernet::ethSetsockopt(int sock, int level, int optname, const void * optval, int optlen) {
 	if (sock < 0) return -1;
 	auto ret = setsockopt(sock,
-	                      level,
-	                      optname,
-#  ifdef WINDOWS
-	                      (char *)
-#  endif
-	                          optval,
-	                      optlen);
+						  level,
+						  optname,
+#ifdef WINDOWS
+						  (char *)
+#endif
+							  optval,
+						  optlen);
 	if (ret != 0) piCout << "setsockopt error:" << ethErrorString();
 	return ret;
 }
@@ -1427,11 +1426,11 @@ int PIEthernet::ethSetsockopt(int sock, int level, int optname, const void * opt
 
 int PIEthernet::ethSetsockoptInt(int sock, int level, int optname, int value) {
 	if (sock < 0) return -1;
-#  ifdef WINDOWS
+#ifdef WINDOWS
 	DWORD
-#  else
+#else
 	int
-#  endif
+#endif
 	so = value;
 	return ethSetsockopt(sock, level, optname, &so, sizeof(so));
 }
@@ -1439,11 +1438,11 @@ int PIEthernet::ethSetsockoptInt(int sock, int level, int optname, int value) {
 
 int PIEthernet::ethSetsockoptBool(int sock, int level, int optname, bool value) {
 	if (sock < 0) return -1;
-#  ifdef WINDOWS
+#ifdef WINDOWS
 	BOOL
-#  else
+#else
 	int
-#  endif
+#endif
 		so = (value ? 1 : 0);
 	return ethSetsockopt(sock, level, optname, &so, sizeof(so));
 }
@@ -1451,12 +1450,12 @@ int PIEthernet::ethSetsockoptBool(int sock, int level, int optname, bool value)
 
 void PIEthernet::ethNonblocking(int sock) {
 	if (sock < 0) return;
-#  ifdef WINDOWS
+#ifdef WINDOWS
 	u_long mode = 1;
 	ioctlsocket(sock, FIONBIO, &mode);
-#  else
+#else
 	fcntl(sock, F_SETFL, O_NONBLOCK);
-#  endif
+#endif
 }
 
 
@@ -1472,7 +1471,7 @@ bool PIEthernet::ethIsWriteable(int sock) {
 	timeout.tv_sec = timeout.tv_usec = 0;
 	::select(fds, nullptr, &fd_test, nullptr, &timeout);
 	return FD_ISSET(sock, &fd_test);*/
-#  ifdef WINDOWS
+#ifdef WINDOWS
 	fd_set fd_test;
 	FD_ZERO(&fd_test);
 	FD_SET(sock, &fd_test);
@@ -1480,12 +1479,10 @@ bool PIEthernet::ethIsWriteable(int sock) {
 	timeout.tv_sec = timeout.tv_usec = 0;
 	::select(0, nullptr, &fd_test, nullptr, &timeout);
 	return FD_ISSET(sock, &fd_test);
-#  else
+#else
 	int ret       = 0;
 	socklen_t len = sizeof(ret);
 	getsockopt(sock, SOL_SOCKET, SO_ERROR, (char *)&ret, &len);
 	return ret == 0;
-#  endif
+#endif
 }
-
-#endif // PIP_NO_SOCKET

libs/main/io_devices/piethernet.h

@@ -26,17 +26,14 @@
 #ifndef PIETHERNET_H
 #define PIETHERNET_H
 
-
 #include "piiodevice.h"
 #include "pinetworkaddress.h"
 
-#ifndef PIP_NO_SOCKET
-
-#  ifdef ANDROID
+#ifdef ANDROID
 struct
-#  else
+#else
 class
-#  endif
+#endif
 	sockaddr;
 
 class PIP_EXPORT PIEthernet: public PIIODevice {
@@ -442,7 +439,7 @@ public:
 //! \}
 //! \ioparams
 //! \{
-#  ifdef DOXYGEN
+#ifdef DOXYGEN
 	//! \brief read ip, default ""
 	string ip;
 
@@ -463,7 +460,7 @@ public:
 
 	//! \brief time-to-live for multicast, default 1
 	int multicastTTL;
-#  endif
+#endif
 	//! \}
 
 protected:
@@ -512,9 +509,9 @@ private:
 	static void server_func(void * eth);
 	void setType(Type t, bool reopen = true);
 	bool connectTCP();
-#  ifdef WINDOWS
+#ifdef WINDOWS
 	long waitForEvent(PIWaitEvent & event, long mask);
-#  endif
+#endif
 
 	static int ethErrorCore();
 	static PIString ethErrorString();
@@ -539,5 +536,4 @@ inline bool operator!=(const PIEthernet::Interface & v0, const PIEthernet::Inter
 	return (v0.name != v1.name || v0.address != v1.address || v0.netmask != v1.netmask);
 }
 
-#endif // PIP_NO_SOCKET
 #endif // PIETHERNET_H

libs/main/io_devices/pifile.cpp

@@ -45,7 +45,7 @@
 #  include <utime.h>
 #endif
 #define S_IFHDN 0x40
-#if defined(QNX) || defined(ANDROID) || defined(MICRO_PIP)
+#if defined(QNX) || defined(ANDROID) || defined(FREERTOS)
 #  define _fopen_call_  fopen
 #  define _fseek_call_  fseek
 #  define _ftell_call_  ftell

libs/main/io_devices/piserial.cpp

@@ -19,37 +19,38 @@
 
 #include "piserial.h"
 
-#ifndef MICRO_PIP
+#include "piconfig.h"
+#include "pidir.h"
+#include "piincludes_p.h"
+#include "pipropertystorage.h"
+#include "pitime.h"
+#include "pitranslator.h"
+#include "piwaitevent_p.h"
 
-#  include "piconfig.h"
-#  include "pidir.h"
-#  include "piincludes_p.h"
-#  include "pipropertystorage.h"
-#  include "pitime.h"
-#  include "pitranslator.h"
-#  include "piwaitevent_p.h"
+#include <errno.h>
 
-#  include <errno.h>
-
-#  if defined(PISERIAL_NO_PINS) || defined(WINDOWS)
-#	define TIOCM_LE  1
-#	define TIOCM_DTR 4
-#	define TIOCM_RTS 7
-#	define TIOCM_CTS 8
-#	define TIOCM_ST  3
-#	define TIOCM_SR  2
-#	define TIOCM_CAR 1
-#	define TIOCM_RNG 9
-#	define TIOCM_DSR 6
+#if defined(MICRO_PIP)
+#  define PISERIAL_NO_PINS
+#endif
+#if defined(PISERIAL_NO_PINS) || defined(WINDOWS)
+#  define TIOCM_LE  1
+#  define TIOCM_DTR 4
+#  define TIOCM_RTS 7
+#  define TIOCM_CTS 8
+#  define TIOCM_ST  3
+#  define TIOCM_SR  2
+#  define TIOCM_CAR 1
+#  define TIOCM_RNG 9
+#  define TIOCM_DSR 6
+#endif
+#ifdef WINDOWS
+#  ifndef INITGUID
+#	define INITGUID
+#	include <guiddef.h>
+#	undef INITGUID
+#  else
+#	include <guiddef.h>
 #  endif
-#  ifdef WINDOWS
-#	ifndef INITGUID
-#	  define INITGUID
-#	  include <guiddef.h>
-#	  undef INITGUID
-#	else
-#	  include <guiddef.h>
-#	endif
 // clang-format off
 #  include <ntddmodm.h>
 #  include <winreg.h>
@@ -58,89 +59,89 @@
 #  include <cfgmgr32.h>
 #  include <setupapi.h>
 // clang-format on
-#	define B50      50
-#	define B75      75
-#	define B110     110
-#	define B300     300
-#	define B600     600
-#	define B1200    1200
-#	define B2400    2400
-#	define B4800    4800
-#	define B9600    9600
-#	define B14400   14400
-#	define B19200   19200
-#	define B38400   38400
-#	define B57600   57600
-#	define B115200  115200
-#	define B230400  230400
-#	define B460800  460800
-#	define B500000  500000
-#	define B576000  576000
-#	define B921600  921600
-#	define B1000000 1000000
-#	define B1152000 1152000
-#	define B1500000 1500000
-#	define B2000000 2000000
-#	define B2500000 2500000
-#	define B3000000 3000000
-#	define B3500000 3500000
-#	define B4000000 4000000
-#  else
-#	include <fcntl.h>
-#	include <sys/ioctl.h>
-#	include <termios.h>
-#	ifndef B50
-#	  define B50 0000001
-#	endif
-#	ifndef B75
-#	  define B75 0000002
-#	endif
-#	ifndef B230400
-#	  define B230400 0010003
-#	endif
-#	ifndef B460800
-#	  define B460800 0010004
-#	endif
-#	ifndef B500000
-#	  define B500000 0010005
-#	endif
-#	ifndef B576000
-#	  define B576000 0010006
-#	endif
-#	ifndef B921600
-#	  define B921600 0010007
-#	endif
-#	ifndef B1000000
-#	  define B1000000 0010010
-#	endif
-#	ifndef B1152000
-#	  define B1152000 0010011
-#	endif
-#	ifndef B1500000
-#	  define B1500000 0010012
-#	endif
-#	ifndef B2000000
-#	  define B2000000 0010013
-#	endif
-#	ifndef B2500000
-#	  define B2500000 0010014
-#	endif
-#	ifndef B3000000
-#	  define B3000000 0010015
-#	endif
-#	ifndef B3500000
-#	  define B3500000 0010016
-#	endif
-#	ifndef B4000000
-#	  define B4000000 0010017
-#	endif
+#  define B50      50
+#  define B75      75
+#  define B110     110
+#  define B300     300
+#  define B600     600
+#  define B1200    1200
+#  define B2400    2400
+#  define B4800    4800
+#  define B9600    9600
+#  define B14400   14400
+#  define B19200   19200
+#  define B38400   38400
+#  define B57600   57600
+#  define B115200  115200
+#  define B230400  230400
+#  define B460800  460800
+#  define B500000  500000
+#  define B576000  576000
+#  define B921600  921600
+#  define B1000000 1000000
+#  define B1152000 1152000
+#  define B1500000 1500000
+#  define B2000000 2000000
+#  define B2500000 2500000
+#  define B3000000 3000000
+#  define B3500000 3500000
+#  define B4000000 4000000
+#else
+#  include <fcntl.h>
+#  include <sys/ioctl.h>
+#  include <termios.h>
+#  ifndef B50
+#	define B50 0000001
 #  endif
-#  ifndef CRTSCTS
-#	define CRTSCTS 020000000000
+#  ifndef B75
+#	define B75 0000002
 #  endif
-#  ifdef LINUX
-#	include <linux/serial.h>
+#  ifndef B230400
+#	define B230400 0010003
 #  endif
+#  ifndef B460800
+#	define B460800 0010004
+#  endif
+#  ifndef B500000
+#	define B500000 0010005
+#  endif
+#  ifndef B576000
+#	define B576000 0010006
+#  endif
+#  ifndef B921600
+#	define B921600 0010007
+#  endif
+#  ifndef B1000000
+#	define B1000000 0010010
+#  endif
+#  ifndef B1152000
+#	define B1152000 0010011
+#  endif
+#  ifndef B1500000
+#	define B1500000 0010012
+#  endif
+#  ifndef B2000000
+#	define B2000000 0010013
+#  endif
+#  ifndef B2500000
+#	define B2500000 0010014
+#  endif
+#  ifndef B3000000
+#	define B3000000 0010015
+#  endif
+#  ifndef B3500000
+#	define B3500000 0010016
+#  endif
+#  ifndef B4000000
+#	define B4000000 0010017
+#  endif
+#endif
+#ifndef CRTSCTS
+#  define CRTSCTS 020000000000
+#endif
+#ifdef LINUX
+#  include <linux/serial.h>
+#endif
 
 
 //! \class PISerial piserial.h
@@ -176,16 +177,16 @@ REGISTER_DEVICE(PISerial)
 
 PRIVATE_DEFINITION_START(PISerial)
 	PIWaitEvent event;
-#  ifdef WINDOWS
+#ifdef WINDOWS
 	PIWaitEvent event_write;
 	DCB desc, sdesc;
 	HANDLE hCom  = nullptr;
 	DWORD readed = 0, mask = 0;
 	OVERLAPPED overlap, overlap_write;
-#  else
+#else
 	termios desc, sdesc;
 	uint readed = 0;
-#  endif
+#endif
 PRIVATE_DEFINITION_END(PISerial)
 
 
@@ -213,9 +214,9 @@ PISerial::~PISerial() {
 	stopAndWait();
 	close();
 	PRIVATE->event.destroy();
-#  ifdef WINDOWS
+#ifdef WINDOWS
 	PRIVATE->event_write.destroy();
-#  endif
+#endif
 }
 
 
@@ -346,7 +347,7 @@ bool PISerial::setBreak(bool enabled) {
 		piCoutObj << "sendBreak error: \"" << path() << "\" is not opened!";
 		return false;
 	}
-#  ifdef WINDOWS
+#ifdef WINDOWS
 	if (enabled) {
 		if (!SetCommBreak(PRIVATE->hCom)) {
 			piCoutObj << "setBreak error: " << errorString();
@@ -362,14 +363,14 @@ bool PISerial::setBreak(bool enabled) {
 			return true;
 		}
 	}
-#  else
+#else
 	if (ioctl(fd, enabled ? TIOCSBRK : TIOCCBRK) < 0) {
 		piCoutObj << "setBreak error: " << errorString();
 		return false;
 	} else {
 		return true;
 	}
-#  endif
+#endif
 	return false;
 }
 
@@ -379,8 +380,8 @@ bool PISerial::setBit(int bit, bool on, const PIString & bname) {
 		piCoutObj << "setBit" << bname << " error: \"" << path() << "\" is not opened!";
 		return false;
 	}
-#  ifndef PISERIAL_NO_PINS
-#	ifdef WINDOWS
+#ifndef PISERIAL_NO_PINS
+#  ifdef WINDOWS
 	static int bit_map_on[]  = {0, 0, 0, 0, SETDTR, 0, 0, SETRTS, 0, 0, 0};
 	static int bit_map_off[] = {0, 0, 0, 0, CLRDTR, 0, 0, CLRRTS, 0, 0, 0};
 	int action               = (on ? bit_map_on : bit_map_off)[bit];
@@ -391,14 +392,14 @@ bool PISerial::setBit(int bit, bool on, const PIString & bname) {
 		}
 		return true;
 	}
-#	else
+#  else
 	if (ioctl(fd, on ? TIOCMBIS : TIOCMBIC, &bit) < 0) {
 		piCoutObj << "setBit" << bname << " error: " << errorString();
 		return false;
 	}
 	return true;
-#	endif
 #  endif
+#endif
 	piCoutObj << "setBit" << bname << " doesn`t implemented, sorry :-(";
 	return false;
 }
@@ -409,23 +410,23 @@ bool PISerial::isBit(int bit, const PIString & bname) const {
 		piCoutObj << "isBit" << bname << " error: \"" << path() << "\" is not opened!";
 		return false;
 	}
-#  ifndef PISERIAL_NO_PINS
-#	ifdef WINDOWS
-#	else
+#ifndef PISERIAL_NO_PINS
+#  ifdef WINDOWS
+#  else
 	int ret = 0;
 	if (ioctl(fd, TIOCMGET, &ret) < 0) piCoutObj << "isBit" << bname << " error: " << errorString();
 	return ret & bit;
-#	endif
 #  endif
+#endif
 	piCoutObj << "isBit" << bname << " doesn`t implemented, sorry :-(";
 	return false;
 }
 
 
 void PISerial::flush() {
-#  ifndef WINDOWS
+#ifndef WINDOWS
 	if (fd != -1) tcflush(fd, TCIOFLUSH);
-#  endif
+#endif
 }
 
 
@@ -440,9 +441,9 @@ int PISerial::convertSpeed(PISerial::Speed speed) {
 	case S2400: return B2400;
 	case S4800: return B4800;
 	case S9600: return B9600;
-#  ifdef WINDOWS
+#ifdef WINDOWS
 	case S14400: return B14400;
-#  endif
+#endif
 	case S19200: return B19200;
 	case S38400: return B38400;
 	case S57600: return B57600;
@@ -462,13 +463,13 @@ int PISerial::convertSpeed(PISerial::Speed speed) {
 	case S4000000: return B4000000;
 	default: break;
 	}
-#  ifdef WINDOWS
+#ifdef WINDOWS
 	piCoutObj << "Warning: Custom speed %1"_tr("PISerial").arg((int)speed);
 	return (int)speed;
-#  else
+#else
 	piCoutObj << "Warning: Unknown speed %1, using 115200"_tr("PISerial").arg((int)speed);
 	return B115200;
-#  endif
+#endif
 }
 
 
@@ -671,9 +672,9 @@ bool PISerial::send(const void * data, int size) {
 void PISerial::interrupt() {
 	// piCoutObj << "interrupt";
 	PRIVATE->event.interrupt();
-#  ifdef WINDOWS
+#ifdef WINDOWS
 	PRIVATE->event_write.interrupt();
-#  endif
+#endif
 }
 
 
@@ -695,7 +696,7 @@ bool PISerial::openDevice() {
 		}
 	}
 	if (p.isEmpty()) return false;
-#  ifdef WINDOWS
+#ifdef WINDOWS
 	DWORD ds = 0, sm = 0;
 	if (isReadable()) {
 		ds |= GENERIC_READ;
@@ -713,7 +714,7 @@ bool PISerial::openDevice() {
 		return false;
 	}
 	fd = 0;
-#  else
+#else
 	int om = 0;
 	switch (mode()) {
 	case PIIODevice::ReadOnly: om = O_RDONLY; break;
@@ -728,12 +729,12 @@ bool PISerial::openDevice() {
 	tcgetattr(fd, &PRIVATE->desc);
 	PRIVATE->sdesc = PRIVATE->desc;
 	// piCoutObj << "Initialized " << p;
-#  endif
+#endif
 	applySettings();
 	PRIVATE->event.create();
-#  ifdef WINDOWS
+#ifdef WINDOWS
 	PRIVATE->event_write.create();
-#  endif
+#endif
 
 	return true;
 }
@@ -744,28 +745,28 @@ bool PISerial::closeDevice() {
 		stopThreadedRead();
 	}
 	if (fd != -1) {
-#  ifdef WINDOWS
+#ifdef WINDOWS
 		SetCommState(PRIVATE->hCom, &PRIVATE->sdesc);
 		SetCommMask(PRIVATE->hCom, PRIVATE->mask);
 		// piCoutObj << "close" <<
 		CloseHandle(PRIVATE->hCom);
 		PRIVATE->hCom = 0;
-#  else
+#else
 		tcsetattr(fd, TCSANOW, &PRIVATE->sdesc);
 		::close(fd);
-#  endif
+#endif
 		fd = -1;
 	}
 	PRIVATE->event.destroy();
-#  ifdef WINDOWS
+#ifdef WINDOWS
 	PRIVATE->event_write.destroy();
-#  endif
+#endif
 	return true;
 }
 
 
 void PISerial::applySettings() {
-#  ifdef WINDOWS
+#ifdef WINDOWS
 	if (fd == -1) return;
 	setTimeouts();
 	GetCommMask(PRIVATE->hCom, &PRIVATE->mask);
@@ -791,7 +792,7 @@ void PISerial::applySettings() {
 		piCoutObj << "Unable to set comm state for \"%1\""_tr("PISerial").arg(path());
 		return;
 	}
-#  else
+#else
 	if (fd == -1) return;
 	tcgetattr(fd, &PRIVATE->desc);
 	PRIVATE->desc.c_oflag = PRIVATE->desc.c_lflag = PRIVATE->desc.c_cflag = 0;
@@ -825,12 +826,12 @@ void PISerial::applySettings() {
 		piCoutObj << "Can`t set attributes for \"%1\""_tr("PISerial").arg(path());
 		return;
 	}
-#  endif
+#endif
 }
 
 
 void PISerial::setTimeouts() {
-#  ifdef WINDOWS
+#ifdef WINDOWS
 	COMMTIMEOUTS times;
 	if (isOptionSet(BlockingRead)) {
 		times.ReadIntervalTimeout        = MAXDWORD;
@@ -844,9 +845,9 @@ void PISerial::setTimeouts() {
 	times.WriteTotalTimeoutConstant   = isOptionSet(BlockingWrite) ? 0 : 1;
 	times.WriteTotalTimeoutMultiplier = 0;
 	if (SetCommTimeouts(PRIVATE->hCom, &times) == -1) piCoutObj << "Unable to set timeouts for \"" << path() << "\"";
-#  else
+#else
 	fcntl(fd, F_SETFL, isOptionSet(BlockingRead) ? 0 : O_NONBLOCK);
-#  endif
+#endif
 }
 
 
@@ -865,7 +866,7 @@ void PISerial::setTimeouts() {
 //!
 //! \~\sa \a readData(), \a readString()
 ssize_t PISerial::readDevice(void * read_to, ssize_t max_size) {
-#  ifdef WINDOWS
+#ifdef WINDOWS
 	if (!canRead()) return -1;
 	if (sending) return -1;
 	// piCoutObj << "read ..." << PRIVATE->hCom << max_size;
@@ -895,7 +896,7 @@ ssize_t PISerial::readDevice(void * read_to, ssize_t max_size) {
 		return -1;
 	// piCoutObj << "read" << (PRIVATE->readed) << errorString();
 	return PRIVATE->readed;
-#  else
+#else
 	if (!canRead()) return -1;
 	if (isOptionSet(PIIODevice::BlockingRead)) {
 		if (!PRIVATE->event.wait(fd)) return -1;
@@ -910,7 +911,7 @@ ssize_t PISerial::readDevice(void * read_to, ssize_t max_size) {
 		}
 	}
 	return ret;
-#  endif
+#endif
 }
 
 
@@ -919,7 +920,7 @@ ssize_t PISerial::writeDevice(const void * data, ssize_t max_size) {
 		// piCoutObj << "Can`t write to uninitialized COM";
 		return -1;
 	}
-#  ifdef WINDOWS
+#ifdef WINDOWS
 	DWORD wrote(0);
 	// piCoutObj << "send ..." << max_size;// << ": " << PIString((char*)data, max_size);
 	sending = true;
@@ -931,11 +932,11 @@ ssize_t PISerial::writeDevice(const void * data, ssize_t max_size) {
 	}
 	sending = false;
 	// piCoutObj << "send ok" << wrote;// << " bytes in " << path();
-#  else
+#else
 	ssize_t wrote;
 	wrote = ::write(fd, data, max_size);
 	if (isOptionSet(BlockingWrite)) tcdrain(fd);
-#  endif
+#endif
 	return (ssize_t)wrote;
 	// piCoutObj << "Error while sending";
 }
@@ -1060,9 +1061,9 @@ void PISerial::configureFromVariantDevice(const PIPropertyStorage & d) {
 PIVector<int> PISerial::availableSpeeds() {
 	PIVector<int> spds;
 	spds << 50 << 75 << 110 << 300 << 600 << 1200 << 2400 << 4800 << 9600 <<
-#  ifdef WINDOWS
+#ifdef WINDOWS
 		14400 <<
-#  endif
+#endif
 		19200 << 38400 << 57600 << 115200 << 230400 << 460800 << 500000 << 576000 << 921600 << 1000000 << 1152000 << 1500000 << 2000000
 		 << 2500000 << 3000000 << 3500000 << 4000000;
 	return spds;
@@ -1078,7 +1079,7 @@ PIStringList PISerial::availableDevices(bool test) {
 }
 
 
-#  ifdef WINDOWS
+#ifdef WINDOWS
 PIString devicePortName(HDEVINFO deviceInfoSet, PSP_DEVINFO_DATA deviceInfoData) {
 	PIString ret;
 	const HKEY key = SetupDiOpenDevRegKey(deviceInfoSet, deviceInfoData, DICS_FLAG_GLOBAL, 0, DIREG_DEV, KEY_READ);
@@ -1146,13 +1147,13 @@ bool parseID(PIString str, PISerial::DeviceInfo & di) {
 	if (i > 0) di.pID = str.mid(i + 4, 4).toInt(16);
 	return (di.vID > 0) && (di.pID > 0);
 }
-#  endif
+#endif
 
 
 PIVector<PISerial::DeviceInfo> PISerial::availableDevicesInfo(bool test) {
 	PIVector<DeviceInfo> ret;
 	DeviceInfo di;
-#  ifdef WINDOWS
+#ifdef WINDOWS
 	static const GUID guids[]  = {GUID_DEVINTERFACE_MODEM, GUID_DEVINTERFACE_COMPORT};
 	static const int guids_cnt = sizeof(guids) / sizeof(GUID);
 	for (int i = 0; i < guids_cnt; ++i) {
@@ -1181,12 +1182,12 @@ PIVector<PISerial::DeviceInfo> PISerial::availableDevicesInfo(bool test) {
 		}
 		SetupDiDestroyDeviceInfoList(dis);
 	}
-#  else
-#	ifndef ANDROID
+#else
+#  ifndef ANDROID
 	PIStringList prefixes;
-#	  ifdef QNX
+#	ifdef QNX
 	prefixes << "ser";
-#	  else
+#	else
 	prefixes << "ttyS"
 			 << "ttyO"
 			 << "ttyUSB"
@@ -1197,14 +1198,14 @@ PIVector<PISerial::DeviceInfo> PISerial::availableDevicesInfo(bool test) {
 			 << "ttyAMA"
 			 << "rfcomm"
 			 << "ircomm";
-#		ifdef FREE_BSD
+#	  ifdef FREE_BSD
 	prefixes << "cu";
-#		endif
-#		ifdef MAC_OS
+#	  endif
+#	  ifdef MAC_OS
 	prefixes.clear();
 	prefixes << "cu."
 			 << "tty.";
-#		endif
+#	  endif
 	PIFile file_prefixes("/proc/tty/drivers", PIIODevice::ReadOnly);
 	if (file_prefixes.open()) {
 		PIString fc = PIString::fromAscii(file_prefixes.readAll()), line, cpref;
@@ -1225,18 +1226,18 @@ PIVector<PISerial::DeviceInfo> PISerial::availableDevicesInfo(bool test) {
 		}
 		prefixes.removeDuplicates();
 	}
-#	  endif
+#	endif
 	PIDir dir("/dev");
 	PIVector<PIFile::FileInfo> de = dir.entries();
-#	  ifdef LINUX
+#	ifdef LINUX
 	char linkbuf[1024];
-#	  endif
+#	endif
 	for (const auto & e: de) { // TODO changes in FileInfo
 		for (const auto & p: prefixes) {
 			if (e.name().startsWith(p)) {
-				di          = DeviceInfo();
-				di.path     = e.path;
-#	  ifdef LINUX
+				di      = DeviceInfo();
+				di.path = e.path;
+#	ifdef LINUX
 				ssize_t lsz = readlink(("/sys/class/tty/" + e.name()).dataAscii(), linkbuf, 1024);
 				if (lsz > 0) {
 					PIString fpath = "/sys/class/tty/" + PIString(linkbuf, lsz) + "/";
@@ -1252,16 +1253,16 @@ PIVector<PISerial::DeviceInfo> PISerial::availableDevicesInfo(bool test) {
 						if (di.pID > 0) break;
 					}
 				}
-#	  endif
+#	endif
 				ret << di;
 			}
 		}
 	}
-#	endif
 #  endif
+#endif
 	if (test) {
 		for (int i = 0; i < ret.size_s(); ++i) {
-#  ifdef WINDOWS
+#ifdef WINDOWS
 			void * hComm = CreateFileA(ret[i].path.dataAscii(),
 			                           GENERIC_READ,
 			                           FILE_SHARE_READ,
@@ -1270,31 +1271,31 @@ PIVector<PISerial::DeviceInfo> PISerial::availableDevicesInfo(bool test) {
 			                           FILE_ATTRIBUTE_SYSTEM | FILE_FLAG_OVERLAPPED,
 			                           0);
 			if (hComm == INVALID_HANDLE_VALUE) {
-#  else
+#else
 			int fd = ::open(ret[i].path.dataAscii(), O_NOCTTY | O_RDONLY);
 			if (fd == -1) {
-#  endif
+#endif
 				ret.remove(i);
 				--i;
 				continue;
 			}
 			bool rok = true;
-#  ifndef WINDOWS
+#ifndef WINDOWS
 			int void_ = 0;
 			fcntl(fd, F_SETFL, O_NONBLOCK);
 			if (::read(fd, &void_, 1) == -1) rok = errno != EIO;
 
-#  endif
+#endif
 			if (!rok) {
 				ret.remove(i);
 				--i;
 				continue;
 			}
-#  ifdef WINDOWS
+#ifdef WINDOWS
 			CloseHandle(hComm);
-#  else
+#else
 			::close(fd);
-#  endif
+#endif
 		}
 	}
 	return ret;
@@ -1308,14 +1309,12 @@ void PISerial::optionsChanged() {
 
 void PISerial::threadedReadBufferSizeChanged() {
 	if (!isOpened()) return;
-#  if defined(LINUX)
+#if defined(LINUX)
 	serial_struct ss;
 	ioctl(fd, TIOCGSERIAL, &ss);
 	// piCoutObj << "b" << ss.xmit_fifo_size;
 	ss.xmit_fifo_size = piMaxi(threadedReadBufferSize(), 4096);
 	ioctl(fd, TIOCSSERIAL, &ss);
 	// piCoutObj << "a" << ss.xmit_fifo_size;
-#  endif
+#endif
 }
-
-#endif // MICRO_PIP

libs/main/piplatform.h

@@ -51,14 +51,8 @@
 #ifdef PIP_FREERTOS
 #  define FREERTOS
 #endif
-#ifdef MICRO_PIP
-#  ifndef FREERTOS
-#	define PIP_NO_THREADS
-#  endif
-#  ifndef LWIP
-#	define PIP_NO_SOCKET
-#  endif
-#  define PISERIAL_NO_PINS
+#if defined(FREERTOS) || defined(PLATFORMIO)
+#  define MICRO_PIP
 #endif
 #ifndef WINDOWS
 #  ifndef QNX

libs/main/serialization/pijson.cpp

@@ -400,9 +400,9 @@ PIJSON PIJSON::parseValue(PIString & s) {
 	s.trim();
 	if (s.isEmpty()) return ret;
 	if (s[0] == '{') {
-		ret = parseObject(s.takeRange('{', '}'));
+		ret = parseObject(s.takeRange('{', '}').trim());
 	} else if (s[0] == '[') {
-		ret = parseArray(s.takeRange('[', ']'));
+		ret = parseArray(s.takeRange('[', ']').trim());
 	} else {
 		s.trim();
 		if (s.startsWith('"')) {

libs/main/serialization/pivaluetree_conversions.cpp

@@ -42,6 +42,14 @@ PIString mask(const PIString & str) {
 	return ret;
 }
 
+PIString overrideFile(PIString path) {
+	if (path.isEmpty()) return {};
+	PIFile::FileInfo fi(path);
+	auto ext = fi.extension();
+	path.insert(path.size_s() - ext.size_s() - (ext.isEmpty() ? 0 : 1), ".override");
+	return path;
+}
+
 
 PIValueTree PIValueTreeConversions::fromPropertyStorage(const PIPropertyStorage & ps) {
 	PIValueTree ret;
@@ -292,7 +300,11 @@ PIString toTextTree(const PIValueTree & root, PIString prefix, PIValueTreeConver
 		ret += "\n[" + prefix + "]\n";
 		if (root.isArray() && options[PIValueTreeConversions::WithAttributes]) ret += toTextTreeAttributes(root, "", options);
 		for (const auto & c: root.children()) {
-			PIString cp = prefix;
+			if (c.hasChildren()) continue;
+			ret += toTextTree(c, prefix, options);
+		}
+		for (const auto & c: root.children()) {
+			if (!c.hasChildren()) continue;
 			ret += toTextTree(c, prefix, options);
 		}
 	} else {
@@ -315,9 +327,13 @@ PIString toTextTree(const PIValueTree & root, PIString prefix, PIValueTreeConver
 PIString PIValueTreeConversions::toText(const PIValueTree & root, Options options) {
 	PIString ret;
 	for (const auto & c: root.children()) {
-		ret += toTextTree(c, PIString(), options);
+		if (c.hasChildren()) continue;
+		ret += toTextTree(c, {}, options);
+	}
+	for (const auto & c: root.children()) {
+		if (!c.hasChildren()) continue;
+		ret += toTextTree(c, {}, options);
 	}
-
 	return ret;
 }
 
@@ -329,13 +345,26 @@ PIValueTree PIValueTreeConversions::fromText(const PIString & str) {
 
 
 PIValueTree PIValueTreeConversions::fromJSONFile(const PIString & path) {
-	return PIValueTreeConversions::fromJSON(PIJSON::fromJSON(PIString::fromUTF8(PIFile::readAll(path))));
+	auto ret = PIValueTreeConversions::fromJSON(PIJSON::fromJSON(PIString::fromUTF8(PIFile::readAll(path))));
+	auto ofp = overrideFile(path);
+	if (PIFile::isExists(ofp)) {
+		auto override_vt = PIValueTreeConversions::fromJSON(PIJSON::fromJSON(PIString::fromUTF8(PIFile::readAll(ofp))));
+		ret.merge(override_vt);
+	}
+	return ret;
 }
 
 
 PIValueTree PIValueTreeConversions::fromTextFile(const PIString & path) {
 	PIFile f(path, PIIODevice::ReadOnly);
-	return PIValueTreeConversions::fromText(&f);
+	auto ret = PIValueTreeConversions::fromText(&f);
+	auto ofp = overrideFile(path);
+	if (PIFile::isExists(ofp)) {
+		PIFile of(ofp, PIIODevice::ReadOnly);
+		auto override_vt = PIValueTreeConversions::fromText(&of);
+		ret.merge(override_vt);
+	}
+	return ret;
 }
 
 

libs/main/system/pihidevice.cpp

@@ -122,6 +122,10 @@ bool PIHIDevice::open(const PIHIDeviceInfo & device) {
 		return false;
 	}
 	HidD_GetPreparsedData(PRIVATE->deviceHandle, &PRIVATE->preparsed);
+	if (!PRIVATE->preparsed) {
+		close();
+		return false;
+	}
 	return true;
 #endif
 }
@@ -338,12 +342,12 @@ PIVector<PIHIDeviceInfo> PIHIDevice::allDevices(bool try_open) {
 
 	PIDir hid_dir("/sys/bus/hid/devices"_a);
 	auto hid_devs = hid_dir.entries();
-	for (auto hd: hid_devs) {
+	for (const auto & hd: hid_devs) {
 		// piCout << d.path;
 		if (!isDir(hd)) continue;
 		PIDir dir_input(hd.path + "/input"_a);
 		auto hid_inputs = dir_input.entries();
-		for (auto hd_i: hid_inputs) {
+		for (const auto & hd_i: hid_inputs) {
 			if (!isDir(hd_i)) continue;
 			// now in /sys/bus/hid/devices/<dev>/input/input<N>
 			// piCout << hd_i.path;
@@ -360,7 +364,7 @@ PIVector<PIHIDeviceInfo> PIHIDevice::allDevices(bool try_open) {
 			PIDir dir_e(hd_i.path);
 			PIStringList devs;
 			auto dl_e = dir_e.entries();
-			for (auto d_e: dl_e) {
+			for (const auto & d_e: dl_e) {
 				if (!d_e.isDir() || d_e.flags[PIFile::FileInfo::Dot] || d_e.flags[PIFile::FileInfo::DotDot]) continue;
 				devs << d_e.name();
 			}
@@ -388,7 +392,7 @@ PIVector<PIHIDeviceInfo> PIHIDevice::allDevices(bool try_open) {
 				if (test_f.isClosed()) continue;
 			}
 
-			ullong ev     = readFile(hd_i.path + "/capabilities/ev"_a).toULLong(16);
+			// ullong ev     = readFile(hd_i.path + "/capabilities/ev"_a).toULLong(16);
 
 			auto readAxes = [readFile, checkBit, &hd_i, &dev](const PIString & file, bool is_relative) {
 				PIVector<PIHIDeviceInfo::AxisInfo> ret;
@@ -524,6 +528,7 @@ PIVector<PIHIDeviceInfo> PIHIDevice::allDevices(bool try_open) {
 		PHIDP_PREPARSED_DATA preparsed = nullptr;
 		if (HidD_GetPreparsedData(deviceHandle, &preparsed) == FALSE) {
 			piCout << "HidD_GetPreparsedData error:" << errorString();
+			CloseHandle(deviceHandle);
 			continue;
 		}
 		// auto pp = PIByteArray(preparsed, 64);

libs/main/text/pistring.cpp

@@ -206,7 +206,10 @@ PIString PIString::dtos(const double num, char format, int precision) {
 	if (wr > 4) wr = 4;
 	f[2 + wr] = format;
 	f[3 + wr] = 0;
-	pisprintf(f, num);
+	char ch[256];
+	piZeroMemory(ch, 256);
+	snprintf(ch, 256, f, num);
+	return PIStringAscii(ch).replaceAll(',', '.');
 }
 #undef pisprintf
 
@@ -466,7 +469,7 @@ void PIString::buildData(const char * cp) const {
 	UErrorCode e((UErrorCode)0);
 	UConverter * cc = ucnv_open(cp, &e);
 	if (cc) {
-		const size_t len = MB_CUR_MAX * size() + 1;
+		const size_t len = UCNV_GET_MAX_BYTES_FOR_STRING(size(), ucnv_getMaxCharSize(cc)) + 1; // MB_CUR_MAX * size() + 1;
 		data_            = (char *)malloc(len);
 		int sz           = ucnv_fromUChars(cc, data_, len, (const UChar *)(d.data()), d.size_s(), &e);
 		ucnv_close(cc);

libs/main/types/pivaluetree.cpp

@@ -124,6 +124,23 @@ void PIValueTree::applyValues(const PIValueTree & root, bool recursive) {
 }
 
 
+void PIValueTree::merge(const PIValueTree & root) {
+	if (_is_null) return;
+	for (const auto & c: root._children) {
+		bool found = false;
+		for (auto & i: _children) {
+			if (c.name() == i.name()) {
+				if (c.isValid()) i._value = c._value;
+				i.merge(c);
+				found = true;
+				break;
+			}
+		}
+		if (!found) _children << c;
+	}
+}
+
+
 PIVariant PIValueTree::childValue(const PIString & child_name, const PIVariant & default_value, bool * exists) const {
 	const PIValueTree & node = child(child_name);
 	if (node.isNull()) {

libs/main/types/pivaluetree.h

@@ -170,6 +170,13 @@ public:
 	//! \param recursive Если установлено в true, то значения будут применяться рекурсивно к дочерним узлам.
 	void applyValues(const PIValueTree & root, bool recursive = true);
 
+	//! \~\brief
+	//! \~english Set or add the values of a given %PIValueTree object to the current %PIValueTree object.
+	//! \param root The %PIValueTree object whose values are to be merged.
+	//! \~russian Устанавливает или добавляет значения данного объекта %PIValueTree к текущему объекту %PIValueTree.
+	//! \param root Объект %PIValueTree, значения которого должны быть добавлены.
+	void merge(const PIValueTree & root);
+
 	//! \~\brief
 	//! \~english Returns the children of the current %PIValueTree object.
 	//! \~russian Возвращает дочерние элементы текущего объекта %PIValueTree.

tests/math/testpivector2d.cpp

@@ -1,85 +1,1797 @@
+#include "pistring.h"
 #include "pivector2d.h"
 
 #include "gtest/gtest.h"
+#include <numeric>
 
-int ROWS_COUNT_INIT     = 31;
+size_t ROWS_COUNT_INIT  = 31;
+size_t COLS_COUNT_INIT  = 34;
 int ROWS_COUNT_INCREASE = 41;
-int ROWS_COUNT_REDUCE   = 22;
-
-int COLS_COUNT_INIT     = 34;
 int COLS_COUNT_INCREASE = 44;
+int ROWS_COUNT_REDUCE   = 22;
 int COLS_COUNT_REDUCE   = 13;
 
-void assert_fill_with(PIVector2D<int> vec, int rows, int cols) {
-	for (int r = 0; r < rows; r++) {
-		for (int c = 0; c < cols; c++) {
-			ASSERT_EQ(vec.element(r, c), r * COLS_COUNT_INIT + c);
+void fill_with_sequential(PIVector2D<int> & vec, int rows, int cols) {
+	for (int r = 0; r < rows; ++r) {
+		for (int c = 0; c < cols; ++c) {
+			vec.element(r, c) = r * cols + c;
 		}
 	}
 }
 
-class Vector2D: public ::testing::Test {
+void assert_fill_with_sequential(const PIVector2D<int> & vec, int rows, int cols) {
+	ASSERT_EQ(vec.rows(), rows);
+	ASSERT_EQ(vec.cols(), cols);
+	for (int r = 0; r < rows; ++r) {
+		for (int c = 0; c < cols; ++c) {
+			ASSERT_EQ(vec.element(r, c), r * cols + c);
+		}
+	}
+}
+
+class Vector2DTest: public ::testing::Test {
 protected:
 	PIVector2D<int> vec = PIVector2D<int>(ROWS_COUNT_INIT, COLS_COUNT_INIT);
 
-	void SetUp() override {
-		for (int r = 0; r < ROWS_COUNT_INIT; ++r) {
-			for (int c = 0; c < COLS_COUNT_INIT; ++c) {
-				vec.element(r, c) = r * COLS_COUNT_INIT + c;
+	void SetUp() override { fill_with_sequential(vec, ROWS_COUNT_INIT, COLS_COUNT_INIT); }
+};
+
+// ==================== CONSTRUCTOR TESTS ====================
+TEST_F(Vector2DTest, defaultConstructor_createsEmptyVector) {
+	PIVector2D<int> emptyVec;
+	EXPECT_TRUE(emptyVec.isEmpty());
+	EXPECT_EQ(emptyVec.rows(), 0);
+	EXPECT_EQ(emptyVec.cols(), 0);
+	EXPECT_EQ(emptyVec.size(), 0);
+}
+
+TEST_F(Vector2DTest, sizedConstructor_createsCorrectDimensions) {
+	PIVector2D<int> testVec(5, 3, 42);
+	EXPECT_EQ(testVec.rows(), 5);
+	EXPECT_EQ(testVec.cols(), 3);
+	EXPECT_EQ(testVec.size(), 15);
+
+	for (size_t r = 0; r < 5; ++r) {
+		for (size_t c = 0; c < 3; ++c) {
+			EXPECT_EQ(testVec.element(r, c), 42);
+		}
+	}
+}
+
+TEST_F(Vector2DTest, fromPlainVector_constructor_reshapesCorrectly) {
+	PIVector<int> plain(20);
+	std::iota(plain.data(), plain.data() + 20, 0);
+
+	PIVector2D<int> vec2d(4, 5, plain);
+	EXPECT_EQ(vec2d.rows(), 4);
+	EXPECT_EQ(vec2d.cols(), 5);
+
+	for (size_t r = 0; r < 4; ++r) {
+		for (size_t c = 0; c < 5; ++c) {
+			EXPECT_EQ(vec2d.element(r, c), static_cast<int>(r * 5 + c));
+		}
+	}
+}
+
+TEST_F(Vector2DTest, fromPlainVector_move_constructor_reshapesCorrectly) {
+	PIVector<int> plain(20);
+	std::iota(plain.data(), plain.data() + 20, 0);
+
+	PIVector2D<int> vec2d(4, 5, std::move(plain));
+	EXPECT_EQ(vec2d.rows(), 4);
+	EXPECT_EQ(vec2d.cols(), 5);
+	EXPECT_TRUE(plain.isEmpty()); // Moved-from state
+
+	for (size_t r = 0; r < 4; ++r) {
+		for (size_t c = 0; c < 5; ++c) {
+			EXPECT_EQ(vec2d.element(r, c), static_cast<int>(r * 5 + c));
+		}
+	}
+}
+
+TEST_F(Vector2DTest, fromVectorOfVectors_constructor_reshapesCorrectly) {
+	PIVector<PIVector<int>> vectors;
+	vectors << PIVector<int>({1, 2, 3}) << PIVector<int>({4, 5, 6}) << PIVector<int>({7, 8, 9});
+
+	PIVector2D<int> vec2d(vectors);
+	EXPECT_EQ(vec2d.rows(), 3);
+	EXPECT_EQ(vec2d.cols(), 3);
+
+	EXPECT_EQ(vec2d.element(0, 0), 1);
+	EXPECT_EQ(vec2d.element(1, 1), 5);
+	EXPECT_EQ(vec2d.element(2, 2), 9);
+}
+
+// ==================== CAPACITY TESTS ====================
+TEST_F(Vector2DTest, sizeMethods_returnCorrectValues) {
+	EXPECT_EQ(vec.rows(), ROWS_COUNT_INIT);
+	EXPECT_EQ(vec.cols(), COLS_COUNT_INIT);
+	EXPECT_EQ(vec.size(), ROWS_COUNT_INIT * COLS_COUNT_INIT);
+	EXPECT_EQ(vec.size_s(), static_cast<ssize_t>(ROWS_COUNT_INIT * COLS_COUNT_INIT));
+	EXPECT_EQ(vec.length(), ROWS_COUNT_INIT * COLS_COUNT_INIT);
+	EXPECT_FALSE(vec.isEmpty());
+	EXPECT_TRUE(vec.isNotEmpty());
+	EXPECT_GE(vec.capacity(), vec.size());
+}
+
+// ==================== ELEMENT ACCESS TESTS ====================
+TEST_F(Vector2DTest, element_access_returnsCorrectValues) {
+	EXPECT_EQ(vec.element(5, 7), 5 * COLS_COUNT_INIT + 7);
+	EXPECT_EQ(vec.at(10, 20), 10 * COLS_COUNT_INIT + 20);
+
+	vec.element(15, 15) = 999;
+	EXPECT_EQ(vec.element(15, 15), 999);
+}
+
+TEST_F(Vector2DTest, row_proxy_allows_elementAccess) {
+	auto row = vec[5];
+	EXPECT_EQ(row.size(), COLS_COUNT_INIT);
+	EXPECT_EQ(row[7], 5 * COLS_COUNT_INIT + 7);
+
+	row[10] = 123;
+	EXPECT_EQ(vec.element(5, 10), 123);
+}
+
+TEST_F(Vector2DTest, row_proxy_data_pointer_works) {
+	auto row  = vec[10];
+	int * ptr = row.data();
+	EXPECT_EQ(ptr, vec.data(10 * COLS_COUNT_INIT));
+
+	ptr[5] = 777;
+	EXPECT_EQ(vec.element(10, 5), 777);
+}
+
+TEST_F(Vector2DTest, row_proxy_const_access_works) {
+	const auto & constVec = vec;
+	auto row              = constVec[5];
+	EXPECT_EQ(row[7], 5 * COLS_COUNT_INIT + 7);
+
+	// Compilation test - uncommenting should fail
+	// row[10] = 123;
+}
+
+TEST_F(Vector2DTest, row_proxy_assignment_works) {
+	PIVector2D<int> other(ROWS_COUNT_INIT, COLS_COUNT_INIT, 42);
+
+	vec[10] = other[10];
+	for (size_t c = 0; c < COLS_COUNT_INIT; ++c) {
+		EXPECT_EQ(vec.element(10, c), 42);
+	}
+
+	PIVector<int> newRow(COLS_COUNT_INIT, 99);
+	vec[15] = newRow;
+	for (size_t c = 0; c < COLS_COUNT_INIT; ++c) {
+		EXPECT_EQ(vec.element(15, c), 99);
+	}
+}
+
+TEST_F(Vector2DTest, row_proxy_toVector_conversion_works) {
+	auto rowVec = vec[7].toVector();
+	EXPECT_EQ(rowVec.size(), COLS_COUNT_INIT);
+	for (size_t c = 0; c < COLS_COUNT_INIT; ++c) {
+		EXPECT_EQ(rowVec[c], vec.element(7, c));
+	}
+}
+
+TEST_F(Vector2DTest, col_proxy_allows_elementAccess) {
+	auto col = vec.col(5);
+	EXPECT_EQ(col.size(), ROWS_COUNT_INIT);
+	EXPECT_EQ(col[10], 10 * COLS_COUNT_INIT + 5);
+
+	col[15] = 456;
+	EXPECT_EQ(vec.element(15, 5), 456);
+}
+
+TEST_F(Vector2DTest, col_proxy_data_pointer_works) {
+	auto col  = vec.col(8);
+	int * ptr = col.data(5); // Start from row 5
+	EXPECT_EQ(ptr, &vec.element(5, 8));
+
+	col[2] = 888; // This should affect row 7
+	EXPECT_EQ(vec.element(2, 8), 888);
+}
+
+TEST_F(Vector2DTest, col_proxy_assignment_works) {
+	PIVector2D<int> other(ROWS_COUNT_INIT, COLS_COUNT_INIT, 42);
+
+	vec.col(12) = other.col(12);
+	for (size_t r = 0; r < ROWS_COUNT_INIT; ++r) {
+		EXPECT_EQ(vec.element(r, 12), 42);
+	}
+
+	PIVector<int> newCol(ROWS_COUNT_INIT, 77);
+	vec.col(20) = newCol;
+	for (size_t r = 0; r < ROWS_COUNT_INIT; ++r) {
+		EXPECT_EQ(vec.element(r, 20), 77);
+	}
+}
+
+TEST_F(Vector2DTest, col_proxy_toVector_conversion_works) {
+	auto colVec = vec.col(9).toVector();
+	EXPECT_EQ(colVec.size(), ROWS_COUNT_INIT);
+	for (size_t r = 0; r < ROWS_COUNT_INIT; ++r) {
+		EXPECT_EQ(colVec[r], vec.element(r, 9));
+	}
+}
+
+TEST_F(Vector2DTest, row_and_col_methods_return_same_as_operator) {
+	auto row1 = vec.row(10);
+	auto row2 = vec[10];
+	EXPECT_EQ(row1[0], row2[0]);
+
+	auto col1 = vec.col(15);
+	auto col2 = vec.col(15); // No operator[] for col
+	EXPECT_EQ(col1[5], col2[5]);
+}
+
+// ==================== PROXY SEARCH TESTS ====================
+TEST_F(Vector2DTest, row_proxy_search_works) {
+	auto row    = vec[10];
+	// indexOf
+	ssize_t idx = row.indexOf(vec.element(10, 5));
+	EXPECT_EQ(idx, 5);
+	EXPECT_EQ(row.indexOf(-999), -1);
+
+	// lastIndexOf (add a duplicate)
+	vec.element(10, 7) = vec.element(10, 5); // duplicate
+	idx                = row.lastIndexOf(vec.element(10, 5));
+	EXPECT_EQ(idx, 7);
+
+	// indexWhere
+	auto isEven       = [](const int & e) { return e % 2 == 0; };
+	ssize_t firstEven = row.indexWhere(isEven);
+	EXPECT_GE(firstEven, 0);
+
+	// lastIndexWhere
+	ssize_t lastEven = row.lastIndexWhere(isEven);
+	EXPECT_GE(lastEven, firstEven);
+}
+
+TEST_F(Vector2DTest, col_proxy_search_works) {
+	auto col    = vec.col(9); // используем столбец 9, где все элементы нечётные
+	ssize_t idx = col.indexOf(vec.element(12, 9));
+	EXPECT_EQ(idx, 12);
+	EXPECT_EQ(col.indexOf(-999), -1);
+
+	vec.element(20, 9) = vec.element(12, 9); // duplicate
+	idx                = col.lastIndexOf(vec.element(12, 9));
+	EXPECT_EQ(idx, 20);
+
+	auto isOdd       = [](const int & e) { return e % 2 != 0; };
+	ssize_t firstOdd = col.indexWhere(isOdd);
+	EXPECT_GE(firstOdd, 0);
+	ssize_t lastOdd = col.lastIndexWhere(isOdd);
+	EXPECT_GE(lastOdd, firstOdd);
+}
+
+TEST_F(Vector2DTest, rowconst_proxy_search_works) {
+	const auto & constVec = vec;
+	const auto row        = constVec[10];
+	ssize_t idx           = row.indexOf(vec.element(10, 5));
+	EXPECT_EQ(idx, 5);
+	idx = row.lastIndexOf(vec.element(10, 5));
+	EXPECT_EQ(idx, 5);
+}
+
+TEST_F(Vector2DTest, colconst_proxy_search_works) {
+	const auto & constVec = vec;
+	auto col              = constVec.col(8);
+	ssize_t idx           = col.indexOf(vec.element(12, 8));
+	EXPECT_EQ(idx, 12);
+	idx = col.lastIndexOf(vec.element(12, 8));
+	EXPECT_EQ(idx, 12);
+}
+
+// ==================== ROW/COLUMN ITERATION TESTS ====================
+TEST_F(Vector2DTest, forEachRow_modifies_rows) {
+	vec.forEachRow([](PIVector2D<int>::Row row) {
+		for (size_t c = 0; c < row.size(); ++c)
+			row[c] = 999;
+	});
+	for (size_t r = 0; r < vec.rows(); ++r)
+		for (size_t c = 0; c < vec.cols(); ++c)
+			EXPECT_EQ(vec.element(r, c), 999);
+}
+
+TEST_F(Vector2DTest, forEachRow_readonly_counts_rows) {
+	size_t count = 0;
+	vec.forEachRow([&count](PIVector2D<int>::RowConst) { ++count; });
+	EXPECT_EQ(count, vec.rows());
+}
+
+TEST_F(Vector2DTest, forEachColumn_modifies_columns) {
+	vec.forEachColumn([](PIVector2D<int>::Col col) {
+		for (size_t r = 0; r < col.size(); ++r)
+			col[r] = 777;
+	});
+	for (size_t r = 0; r < vec.rows(); ++r)
+		for (size_t c = 0; c < vec.cols(); ++c)
+			EXPECT_EQ(vec.element(r, c), 777);
+}
+
+TEST_F(Vector2DTest, forEachColumn_readonly_counts_columns) {
+	size_t count = 0;
+	vec.forEachColumn([&count](PIVector2D<int>::ColConst) { ++count; });
+	EXPECT_EQ(count, vec.cols());
+}
+
+// ==================== MODIFIER TESTS ====================
+TEST_F(Vector2DTest, setRow_replaces_row_correctly) {
+	PIVector<int> newRow(COLS_COUNT_INIT);
+	std::iota(newRow.data(), newRow.data() + COLS_COUNT_INIT, 100);
+
+	vec.setRow(12, newRow);
+	for (size_t c = 0; c < COLS_COUNT_INIT; ++c) {
+		EXPECT_EQ(vec.element(12, c), static_cast<int>(100 + c));
+	}
+}
+
+TEST_F(Vector2DTest, setRow_with_shorter_vector_truncates) {
+	PIVector<int> shortRow(COLS_COUNT_INIT - 5, 999);
+	vec.setRow(8, shortRow);
+
+	for (size_t c = 0; c < COLS_COUNT_INIT - 5; ++c) {
+		EXPECT_EQ(vec.element(8, c), 999);
+	}
+	// Rest unchanged
+	EXPECT_EQ(vec.element(8, COLS_COUNT_INIT - 5), 8 * COLS_COUNT_INIT + COLS_COUNT_INIT - 5);
+}
+
+TEST_F(Vector2DTest, addRow_appends_row_to_empty) {
+	PIVector2D<int> empty;
+	PIVector<int> newRow(5, 42);
+
+	empty.addRow(newRow);
+	EXPECT_EQ(empty.rows(), 1);
+	EXPECT_EQ(empty.cols(), 5);
+	for (size_t c = 0; c < 5; ++c) {
+		EXPECT_EQ(empty.element(0, c), 42);
+	}
+}
+
+TEST_F(Vector2DTest, addRow_appends_row_to_existing) {
+	size_t oldRows = vec.rows();
+	PIVector<int> newRow(COLS_COUNT_INIT, 999);
+
+	vec.addRow(newRow);
+	EXPECT_EQ(vec.rows(), oldRows + 1);
+	EXPECT_EQ(vec.cols(), COLS_COUNT_INIT);
+
+	for (size_t c = 0; c < COLS_COUNT_INIT; ++c) {
+		EXPECT_EQ(vec.element(oldRows, c), 999);
+	}
+}
+
+TEST_F(Vector2DTest, addRow_with_shorter_vector_uses_min) {
+	size_t oldRows   = vec.rows();
+	size_t shortCols = COLS_COUNT_INIT - 10;
+	PIVector<int> shortRow(shortCols, 777);
+
+	vec.addRow(shortRow);
+	EXPECT_EQ(vec.rows(), oldRows + 1);
+	EXPECT_EQ(vec.cols(), COLS_COUNT_INIT); // cols unchanged
+
+	for (size_t c = 0; c < shortCols; ++c) {
+		EXPECT_EQ(vec.element(oldRows, c), 777);
+	}
+	for (size_t c = shortCols; c < COLS_COUNT_INIT; ++c) {
+		EXPECT_EQ(vec.element(oldRows, c), 0); // default initialized
+	}
+}
+
+// ==================== APPEND ROWS TESTS ====================
+
+TEST_F(Vector2DTest, appendRows_adds_rows_at_bottom) {
+	size_t oldRows = vec.rows();
+	size_t oldCols = vec.cols();
+
+	vec.appendRows(5, 42);
+
+	EXPECT_EQ(vec.rows(), oldRows + 5);
+	EXPECT_EQ(vec.cols(), oldCols);
+
+	// Original data preserved
+	for (size_t r = 0; r < oldRows; ++r) {
+		for (size_t c = 0; c < oldCols; ++c) {
+			EXPECT_EQ(vec.element(r, c), static_cast<int>(r * COLS_COUNT_INIT + c));
+		}
+	}
+
+	// New rows filled with 42
+	for (size_t r = oldRows; r < vec.rows(); ++r) {
+		for (size_t c = 0; c < oldCols; ++c) {
+			EXPECT_EQ(vec.element(r, c), 42);
+		}
+	}
+}
+
+TEST_F(Vector2DTest, appendRows_with_zero_count_does_nothing) {
+	auto oldVec = vec;
+	vec.appendRows(0);
+	EXPECT_EQ(vec, oldVec);
+}
+
+TEST_F(Vector2DTest, appendRows_on_empty_matrix) {
+	PIVector2D<int> empty;
+	empty.appendRows(5, 99);
+	EXPECT_TRUE(empty.isNotEmpty());
+	EXPECT_EQ(empty.rows(), 5);
+	EXPECT_EQ(empty.cols(), 1);
+	EXPECT_EQ(empty.size(), empty.entries(99));
+}
+
+TEST_F(Vector2DTest, appendRows_with_default_value) {
+	size_t oldRows = vec.rows();
+
+	vec.appendRows(3);
+
+	for (size_t r = oldRows; r < vec.rows(); ++r) {
+		for (size_t c = 0; c < vec.cols(); ++c) {
+			EXPECT_EQ(vec.element(r, c), 0);
+		}
+	}
+}
+
+// ==================== APPEND COLUMNS TESTS ====================
+
+TEST_F(Vector2DTest, appendColumns_adds_columns_at_right) {
+	size_t oldRows = vec.rows();
+	size_t oldCols = vec.cols();
+
+	vec.appendColumns(3, 99);
+
+	EXPECT_EQ(vec.rows(), oldRows);
+	EXPECT_EQ(vec.cols(), oldCols + 3);
+
+	// Original data preserved in original columns
+	for (size_t r = 0; r < oldRows; ++r) {
+		for (size_t c = 0; c < oldCols; ++c) {
+			EXPECT_EQ(vec.element(r, c), static_cast<int>(r * COLS_COUNT_INIT + c));
+		}
+	}
+
+	// New columns filled with 99
+	for (size_t r = 0; r < oldRows; ++r) {
+		for (size_t c = oldCols; c < vec.cols(); ++c) {
+			EXPECT_EQ(vec.element(r, c), 99);
+		}
+	}
+}
+
+TEST_F(Vector2DTest, appendColumns_with_zero_count_does_nothing) {
+	auto oldVec = vec;
+	vec.appendColumns(0);
+	EXPECT_EQ(vec, oldVec);
+}
+
+TEST_F(Vector2DTest, appendColumns_on_empty_matrix) {
+	PIVector2D<int> empty;
+	empty.appendColumns(5, 99);
+	EXPECT_TRUE(empty.isNotEmpty());
+	EXPECT_EQ(empty.cols(), 5);
+	EXPECT_EQ(empty.rows(), 1);
+	EXPECT_EQ(empty.size(), empty.entries(99));
+}
+
+TEST_F(Vector2DTest, appendColumns_single_column) {
+	auto oldVec = vec;
+
+	vec.appendColumns(1, 77);
+
+	EXPECT_EQ(vec.rows(), oldVec.rows());
+	EXPECT_EQ(vec.cols(), oldVec.cols() + 1);
+
+	// Check original data
+	for (size_t r = 0; r < vec.rows(); ++r) {
+		for (size_t c = 0; c < oldVec.cols(); ++c) {
+			EXPECT_EQ(vec.element(r, c), oldVec.element(r, c));
+		}
+	}
+
+	// Check new column
+	for (size_t r = 0; r < vec.rows(); ++r) {
+            EXPECT_EQ(vec.element(r, oldVec.cols()), 77);
+	}
+}
+
+// ==================== DELETE ROWS TESTS ====================
+
+TEST_F(Vector2DTest, deleteRows_removes_rows_from_middle) {
+	size_t oldRows = vec.rows();
+	size_t oldCols = vec.cols();
+
+	vec.deleteRows(5, 3);
+
+	EXPECT_EQ(vec.rows(), oldRows - 3);
+	EXPECT_EQ(vec.cols(), oldCols);
+
+	// Rows before deleted remain
+	for (size_t r = 0; r < 5; ++r) {
+		for (size_t c = 0; c < oldCols; ++c) {
+			EXPECT_EQ(vec.element(r, c), static_cast<int>(r * COLS_COUNT_INIT + c));
+		}
+	}
+
+	// Rows after deleted shifted up
+	for (size_t r = 5; r < vec.rows(); ++r) {
+		for (size_t c = 0; c < oldCols; ++c) {
+			EXPECT_EQ(vec.element(r, c), static_cast<int>((r + 3) * COLS_COUNT_INIT + c));
+		}
+	}
+}
+
+TEST_F(Vector2DTest, deleteRows_at_end_works) {
+	size_t oldRows = vec.rows();
+	size_t oldCols = vec.cols();
+
+	vec.deleteRows(oldRows - 2, 2);
+
+	EXPECT_EQ(vec.rows(), oldRows - 2);
+	EXPECT_EQ(vec.cols(), oldCols);
+
+	// All remaining rows should have original content
+	for (size_t r = 0; r < vec.rows(); ++r) {
+		for (size_t c = 0; c < oldCols; ++c) {
+			EXPECT_EQ(vec.element(r, c), static_cast<int>(r * COLS_COUNT_INIT + c));
+		}
+	}
+}
+
+TEST_F(Vector2DTest, deleteRows_beyond_bounds_is_limited) {
+	size_t oldRows = vec.rows();
+	size_t oldCols = vec.cols();
+	size_t count = 10;
+
+	vec.deleteRows(oldRows - 2, count);
+
+	EXPECT_EQ(vec.rows(), oldRows - count);
+	EXPECT_EQ(vec.cols(), oldCols);
+
+	// All remaining rows should have original content
+	for (size_t r = 0; r < oldRows; ++r) {
+		for (size_t c = 0; c < vec.cols(); ++c) {
+			EXPECT_EQ(vec.element(r, c), static_cast<int>(r * COLS_COUNT_INIT + c));
+		}
+	}
+
+	// All new rows should have original content
+	for (size_t r = oldRows; r < vec.rows(); ++r) {
+		for (size_t c = 0; c < vec.cols(); ++c) {
+			EXPECT_EQ(vec.element(r, c), static_cast<int>((r+count) * COLS_COUNT_INIT + c));
+		}
+	}
+}
+
+TEST_F(Vector2DTest, deleteRows_invalid_start_does_nothing) {
+	auto oldVec = vec;
+	vec.deleteRows(oldVec.rows() + 10, 2);
+	EXPECT_EQ(vec, oldVec);
+}
+
+TEST_F(Vector2DTest, deleteRows_zero_count_does_nothing) {
+	auto oldVec = vec;
+	vec.deleteRows(5, 0);
+	EXPECT_EQ(vec, oldVec);
+}
+
+TEST_F(Vector2DTest, deleteRows_all_rows_creates_empty) {
+	vec.deleteRows(0, vec.rows());
+	EXPECT_TRUE(vec.isEmpty());
+	EXPECT_EQ(vec.rows(), 0);
+	EXPECT_EQ(vec.cols(), 0);
+}
+
+// ==================== DELETE COLUMNS TESTS ====================
+
+TEST_F(Vector2DTest, deleteColumns_removes_columns_from_middle) {
+	size_t oldRows = vec.rows();
+	size_t oldCols = vec.cols();
+
+	vec.deleteColumns(4, 3);
+
+	EXPECT_EQ(vec.rows(), oldRows);
+	EXPECT_EQ(vec.cols(), oldCols - 3);
+
+	// Columns before deleted remain
+	for (size_t r = 0; r < oldRows; ++r) {
+		for (size_t c = 0; c < 4; ++c) {
+			EXPECT_EQ(vec.element(r, c), static_cast<int>(r * COLS_COUNT_INIT + c));
+		}
+	}
+
+	// Columns after deleted shifted left
+	for (size_t r = 0; r < oldRows; ++r) {
+		for (size_t c = 4; c < vec.cols(); ++c) {
+			EXPECT_EQ(vec.element(r, c), static_cast<int>(r * COLS_COUNT_INIT + c + 3));
+		}
+	}
+}
+
+TEST_F(Vector2DTest, deleteColumns_at_end_works) {
+	size_t oldRows = vec.rows();
+	size_t oldCols = vec.cols();
+
+	vec.deleteColumns(oldCols - 2, 2);
+
+	EXPECT_EQ(vec.rows(), oldRows);
+	EXPECT_EQ(vec.cols(), oldCols - 2);
+
+	// All remaining columns should have original content
+	for (size_t r = 0; r < oldRows; ++r) {
+		for (size_t c = 0; c < vec.cols(); ++c) {
+			EXPECT_EQ(vec.element(r, c), static_cast<int>(r * COLS_COUNT_INIT + c));
+		}
+	}
+}
+
+TEST_F(Vector2DTest, deleteColumns_beyond_bounds_is_limited) {
+	size_t oldRows = vec.rows();
+	size_t oldCols = vec.cols();
+
+	vec.deleteColumns(oldCols - 2, 10);
+
+	EXPECT_EQ(vec.rows(), oldRows);
+	EXPECT_EQ(vec.cols(), oldCols - 2);
+}
+
+TEST_F(Vector2DTest, deleteColumns_invalid_start_does_nothing) {
+	auto oldVec = vec;
+	vec.deleteColumns(oldVec.cols() + 10, 2);
+	EXPECT_EQ(vec, oldVec);
+}
+
+TEST_F(Vector2DTest, deleteColumns_zero_count_does_nothing) {
+	auto oldVec = vec;
+	vec.deleteColumns(5, 0);
+	EXPECT_EQ(vec, oldVec);
+}
+
+TEST_F(Vector2DTest, deleteColumns_all_columns_preserves_rows) {
+	vec.deleteColumns(0, vec.cols());
+	EXPECT_EQ(vec.rows(), ROWS_COUNT_INIT);
+	EXPECT_EQ(vec.cols(), 0);
+	EXPECT_EQ(vec.size(), 0);
+}
+
+// ==================== ADD COLUMN TESTS ====================
+
+TEST_F(Vector2DTest, addColumn_appends_column_to_empty) {
+	PIVector2D<int> empty;
+	PIVector<int> newCol(5);
+	for (size_t i = 0; i < 5; ++i)
+		newCol[i] = static_cast<int>(100 + i);
+
+	empty.addColumn(newCol);
+
+	EXPECT_EQ(empty.rows(), 5);
+	EXPECT_EQ(empty.cols(), 1);
+	for (size_t r = 0; r < 5; ++r) {
+		EXPECT_EQ(empty.element(r, 0), static_cast<int>(100 + r));
+	}
+}
+
+TEST_F(Vector2DTest, addColumn_appends_column_to_existing) {
+	size_t oldRows = vec.rows();
+	size_t oldCols = vec.cols();
+
+	PIVector<int> newCol(oldRows, [](size_t i){return -900 - (int)i;});
+	vec.addColumn(newCol);
+
+	EXPECT_EQ(vec.rows(), oldRows);
+	EXPECT_EQ(vec.cols(), oldCols + 1);
+
+	// Check that old data is preserved
+	for (size_t r = 0; r < oldRows; ++r) {
+		for (size_t c = 0; c < oldCols; ++c) {
+			EXPECT_EQ(vec.element(r, c), static_cast<int>(r * COLS_COUNT_INIT + c));
+		}
+	}
+
+	// Check new column
+	for (size_t r = 0; r < oldRows; ++r) {
+		EXPECT_EQ(vec.element(r, oldCols), -900 - (int)r);
+	}
+}
+
+TEST_F(Vector2DTest, addColumn_with_shorter_vector_uses_min) {
+	size_t oldRows  = vec.rows();
+	size_t oldCols  = vec.cols();
+	size_t shortLen = oldRows - 10;
+	PIVector<int> shortCol(shortLen, 777);
+
+	vec.addColumn(shortCol);
+
+	EXPECT_EQ(vec.cols(), oldCols + 1);
+
+	// First shortLen rows should be 777
+	for (size_t r = 0; r < shortLen; ++r) {
+		EXPECT_EQ(vec.element(r, oldCols), 777);
+	}
+	// Remaining rows should be default-initialized (0)
+	for (size_t r = shortLen; r < oldRows; ++r) {
+		EXPECT_EQ(vec.element(r, oldCols), 0);
+	}
+}
+
+TEST_F(Vector2DTest, addColumn_with_longer_vector_truncates) {
+	size_t oldRows = vec.rows();
+	size_t oldCols = vec.cols();
+	size_t longLen = oldRows + 10;
+	PIVector<int> longCol(longLen, 555);
+
+	vec.addColumn(longCol);
+
+	EXPECT_EQ(vec.cols(), oldCols + 1);
+
+	// All rows should be 555 (only first oldRows elements are used)
+	for (size_t r = 0; r < oldRows; ++r) {
+		EXPECT_EQ(vec.element(r, oldCols), 555);
+	}
+}
+
+TEST_F(Vector2DTest, addColumn_with_empty_source_does_nothing_on_empty) {
+	PIVector2D<int> empty;
+	PIVector<int> emptyCol;
+
+	empty.addColumn(emptyCol);
+	EXPECT_TRUE(empty.isEmpty());
+	EXPECT_EQ(empty.rows(), 0);
+	EXPECT_EQ(empty.cols(), 0);
+}
+
+TEST_F(Vector2DTest, addColumn_with_empty_source_adds_default_column) {
+	auto oldVec = vec;
+
+	vec.addColumn({});
+
+	EXPECT_EQ(vec.cols(), oldVec.cols());
+	EXPECT_EQ(vec.rows(), oldVec.rows());
+
+	for (size_t r = 0; r < oldVec.rows(); ++r) {
+		for (size_t c = 0; c < oldVec.cols(); ++c) {
+			EXPECT_EQ(vec.element(r, c), oldVec.element(r, c));
+		}
+	}
+}
+
+TEST_F(Vector2DTest, addColumn_with_Col_proxy_works) {
+	auto oldVec           = vec;
+	const size_t colIndex = 5;
+
+	auto srcCol           = oldVec.col(colIndex);
+	vec.addColumn(srcCol);
+
+	EXPECT_EQ(vec.cols(), oldVec.cols() + 1);
+	EXPECT_EQ(vec.rows(), oldVec.rows());
+
+	for (size_t r = 0; r < oldVec.rows(); ++r) {
+		for (size_t c = 0; c < oldVec.cols(); ++c) {
+			EXPECT_EQ(vec.element(r, c), oldVec.element(r, c));
+		}
+	}
+	for (size_t r = 0; r < vec.rows(); ++r) {
+		// EXPECT_EQ(vec.element(r, oldVec.cols()), int());
+		EXPECT_EQ(vec.element(r, oldVec.cols()), oldVec.element(r, colIndex));
+	}
+}
+
+TEST_F(Vector2DTest, addColumn_with_ColConst_proxy_works) {
+	size_t oldRows             = vec.rows();
+	size_t oldCols             = vec.cols();
+
+	const auto & constVec      = vec;
+	auto srcCol                = constVec.col(7);
+	// Need a non-const array to add to
+	PIVector2D<int> mutableVec = vec; // copy
+	mutableVec.addColumn(srcCol);
+
+	EXPECT_EQ(mutableVec.cols(), oldCols + 1);
+
+	for (size_t r = 0; r < oldRows; ++r) {
+		EXPECT_EQ(mutableVec.element(r, oldCols), vec.element(r, 7));
+	}
+}
+
+// ==================== RESIZE TESTS ====================
+class Vector2DResizeTest: public Vector2DTest {
+protected:
+	void assert_resize_reduce_preserves_data(int newRows, int newCols) {
+		vec.resize(newRows, newCols, 0);
+		ASSERT_EQ(vec.rows(), newRows);
+		ASSERT_EQ(vec.cols(), newCols);
+
+		for (int r = 0; r < newRows; ++r) {
+			for (int c = 0; c < newCols; ++c) {
+				EXPECT_EQ(vec.element(r, c), r * COLS_COUNT_INIT + c);
 			}
 		}
 	}
 
-	void resize_reduce_is_data_stay_consistent(int newRowsCount, int newColsCount) {
-		vec.resize(newRowsCount, newColsCount, 0);
-		assert_fill_with(vec, newRowsCount, newColsCount);
-	}
+	void assert_resize_increase_initializes_new(size_t newRows, size_t newCols) {
+		vec.resize(newRows, newCols, 0);
+		ASSERT_EQ(vec.rows(), newRows);
+		ASSERT_EQ(vec.cols(), newCols);
 
-	void resize_increase_is_data_stay_consistent(int newRowsCount, int newColsCount) {
-		vec.resize(newRowsCount, newColsCount, 0);
-		assert_fill_with(vec, ROWS_COUNT_INIT, COLS_COUNT_INIT);
+		// Check old data preserved
+		for (size_t r = 0; r < ROWS_COUNT_INIT; ++r) {
+			for (size_t c = 0; c < COLS_COUNT_INIT; ++c) {
+				EXPECT_EQ(vec.element(r, c), r * COLS_COUNT_INIT + c);
+			}
+		}
 
-		for (int r = 0; r < newRowsCount; ++r) {
-			for (int c = 0; c < newColsCount; ++c) {
-				if (r < ROWS_COUNT_INIT || c < COLS_COUNT_INIT) continue;
-				ASSERT_EQ(vec.element(r, c), 0);
+		// Check new elements initialized to 0
+		for (size_t r = 0; r < newRows; ++r) {
+			for (size_t c = 0; c < newCols; ++c) {
+				if (r >= ROWS_COUNT_INIT || c >= COLS_COUNT_INIT) {
+					EXPECT_EQ(vec.element(r, c), 0);
+				}
 			}
 		}
 	}
 };
 
-TEST_F(Vector2D, resize_is_increase_col_count) {
-	vec.resize(ROWS_COUNT_INIT, COLS_COUNT_INCREASE, 0);
-	ASSERT_EQ(vec.cols(), COLS_COUNT_INCREASE);
+TEST_F(Vector2DResizeTest, resize_increase_both_preserves_data) {
+	assert_resize_increase_initializes_new(ROWS_COUNT_INCREASE, COLS_COUNT_INCREASE);
 }
 
-TEST_F(Vector2D, resize_is_reduce_col_count) {
-	vec.resize(ROWS_COUNT_INIT, COLS_COUNT_REDUCE, 0);
-	ASSERT_EQ(vec.cols(), COLS_COUNT_REDUCE);
+TEST_F(Vector2DResizeTest, resize_increase_rows_only_preserves_data) {
+	assert_resize_increase_initializes_new(ROWS_COUNT_INCREASE, COLS_COUNT_INIT);
 }
 
-TEST_F(Vector2D, resize_is_increase_rows_count) {
-	vec.resize(ROWS_COUNT_INCREASE, COLS_COUNT_INIT, 0);
-	ASSERT_EQ(vec.rows(), ROWS_COUNT_INCREASE);
+TEST_F(Vector2DResizeTest, resize_increase_cols_only_preserves_data) {
+	assert_resize_increase_initializes_new(ROWS_COUNT_INIT, COLS_COUNT_INCREASE);
 }
 
-TEST_F(Vector2D, resize_is_reduce_rows_count) {
-	vec.resize(ROWS_COUNT_REDUCE, COLS_COUNT_INIT, 0);
-	ASSERT_EQ(vec.rows(), ROWS_COUNT_REDUCE);
+TEST_F(Vector2DResizeTest, resize_reduce_both_preserves_data) {
+	assert_resize_reduce_preserves_data(ROWS_COUNT_REDUCE, COLS_COUNT_REDUCE);
 }
 
-TEST_F(Vector2D, resize_increase_both_is_data_stay_consistent) {
-	resize_increase_is_data_stay_consistent(ROWS_COUNT_INCREASE, COLS_COUNT_INCREASE);
+TEST_F(Vector2DResizeTest, resize_reduce_rows_only_preserves_data) {
+	assert_resize_reduce_preserves_data(ROWS_COUNT_REDUCE, COLS_COUNT_INIT);
 }
 
-TEST_F(Vector2D, resize_reduce_cols_is_data_stay_consistent) {
-	resize_reduce_is_data_stay_consistent(ROWS_COUNT_INIT, COLS_COUNT_REDUCE);
+TEST_F(Vector2DResizeTest, resize_reduce_cols_only_preserves_data) {
+	assert_resize_reduce_preserves_data(ROWS_COUNT_INIT, COLS_COUNT_REDUCE);
 }
 
-TEST_F(Vector2D, resize_reduce_rows_is_data_stay_consistent) {
-	resize_reduce_is_data_stay_consistent(ROWS_COUNT_REDUCE, COLS_COUNT_INIT);
+TEST_F(Vector2DResizeTest, resize_to_zero_creates_empty) {
+	vec.resize(0, 0, 42);
+	EXPECT_TRUE(vec.isEmpty());
+	EXPECT_EQ(vec.rows(), 0);
+	EXPECT_EQ(vec.cols(), 0);
 }
 
-TEST_F(Vector2D, resize_reduce_both_is_data_stay_consistent) {
-	resize_reduce_is_data_stay_consistent(ROWS_COUNT_REDUCE, COLS_COUNT_REDUCE);
+TEST_F(Vector2DResizeTest, resize_same_dimensions_does_nothing) {
+	size_t oldRows        = vec.rows();
+	size_t oldCols        = vec.cols();
+	PIVector<int> oldData = vec.asPlainVector();
+
+	vec.resize(oldRows, oldCols, 999);
+	EXPECT_EQ(vec.rows(), oldRows);
+	EXPECT_EQ(vec.cols(), oldCols);
+	EXPECT_EQ(vec.asPlainVector(), oldData); // Data unchanged
+}
+
+// ==================== SEARCH AND LOOKUP TESTS ====================
+TEST_F(Vector2DTest, contains_finds_element_in_flat_vector) {
+	EXPECT_TRUE(vec.contains(5 * COLS_COUNT_INIT + 7));
+	EXPECT_FALSE(vec.contains(-999));
+	EXPECT_TRUE(vec.contains(0));                                     // first element
+	EXPECT_TRUE(vec.contains(ROWS_COUNT_INIT * COLS_COUNT_INIT - 1)); // last element
+}
+
+TEST_F(Vector2DTest, contains_with_start_parameter_works) {
+	int target = 10 * COLS_COUNT_INIT + 15;
+	EXPECT_TRUE(vec.contains(target));
+}
+
+TEST_F(Vector2DTest, contains_vector_of_elements_works) {
+	PIVector<int> searchFor;
+	searchFor << 100 << 200 << 300;
+	EXPECT_TRUE(vec.asPlainVector().containsAll(searchFor));
+
+	searchFor << -999;
+	EXPECT_FALSE(vec.asPlainVector().containsAll(searchFor));
+}
+
+TEST_F(Vector2DTest, entries_counts_occurrences) {
+	// Add some duplicates
+	vec.fill(0);
+	vec.element(5, 5)   = 42;
+	vec.element(10, 10) = 42;
+
+	EXPECT_EQ(vec.entries(42), 2);
+	EXPECT_EQ(vec.entries(-1), 0);
+}
+
+TEST_F(Vector2DTest, entries_with_predicate_counts_matches) {
+	auto isEven   = [](const int & e) { return e % 2 == 0; };
+	int evenCount = 0;
+	for (size_t i = 0; i < vec.size(); ++i) {
+		if (vec.asPlainVector()[i] % 2 == 0) evenCount++;
+	}
+	EXPECT_EQ(vec.entries(isEven), evenCount);
+}
+
+
+// ==================== STATISTICS AND CONDITIONS TESTS ====================
+TEST_F(Vector2DTest, any_returns_true_if_any_match) {
+	auto isNegative = [](const int & e) { return e < 0; };
+	auto isLarge    = [](const int & e) { return e > 1000000; };
+
+	EXPECT_FALSE(vec.any(isNegative));
+	EXPECT_FALSE(vec.any(isLarge));
+
+	auto isPositive = [](const int & e) { return e >= 0; };
+	EXPECT_TRUE(vec.any(isPositive));
+}
+
+TEST_F(Vector2DTest, every_returns_true_if_all_match) {
+	auto isNonNegative = [](const int & e) { return e >= 0; };
+	const int max      = ROWS_COUNT_INIT * COLS_COUNT_INIT;
+	auto isLessThan    = [max](const int & e) { return e < max; };
+
+	EXPECT_TRUE(vec.every(isNonNegative));
+	EXPECT_TRUE(vec.every(isLessThan));
+
+	auto isEven = [](const int & e) { return e % 2 == 0; };
+	EXPECT_FALSE(vec.every(isEven));
+}
+
+// ==================== FILL AND ASSIGN TESTS ====================
+TEST_F(Vector2DTest, fill_sets_all_elements_to_value) {
+	vec.fill(42);
+	for (size_t r = 0; r < ROWS_COUNT_INIT; ++r) {
+		for (size_t c = 0; c < COLS_COUNT_INIT; ++c) {
+			EXPECT_EQ(vec.element(r, c), 42);
+		}
+	}
+}
+
+TEST_F(Vector2DTest, fill_with_function_generates_values) {
+	vec.fill([](size_t i) { return static_cast<int>(i * 2); });
+	for (size_t i = 0; i < vec.size(); ++i) {
+		EXPECT_EQ(vec.asPlainVector()[i], static_cast<int>(i * 2));
+	}
+}
+
+TEST_F(Vector2DTest, assign_is_alias_for_fill) {
+	vec.assign(99);
+	for (size_t i = 0; i < vec.size(); ++i) {
+		EXPECT_EQ(vec.asPlainVector()[i], 99);
+	}
+}
+
+TEST_F(Vector2DTest, assign_with_dimensions_resets_and_fills) {
+	vec.assign(5, 7, 123);
+	EXPECT_EQ(vec.rows(), 5);
+	EXPECT_EQ(vec.cols(), 7);
+	for (size_t r = 0; r < 5; ++r) {
+		for (size_t c = 0; c < 7; ++c) {
+			EXPECT_EQ(vec.element(r, c), 123);
+		}
+	}
+}
+
+// ==================== COMPARISON TESTS ====================
+TEST_F(Vector2DTest, equality_operator_works) {
+	PIVector2D<int> same = vec;
+	EXPECT_EQ(vec, same);
+
+	PIVector2D<int> differentRows(ROWS_COUNT_INIT + 1, COLS_COUNT_INIT);
+	EXPECT_NE(vec, differentRows);
+
+	PIVector2D<int> differentCols(ROWS_COUNT_INIT, COLS_COUNT_INIT + 1);
+	EXPECT_NE(vec, differentCols);
+
+	PIVector2D<int> differentData(ROWS_COUNT_INIT, COLS_COUNT_INIT, 99);
+	EXPECT_NE(vec, differentData);
+}
+
+// ==================== CONVERSION TESTS ====================
+TEST_F(Vector2DTest, toVectors_converts_correctly) {
+	auto vectors = vec.toVectors();
+	EXPECT_EQ(vectors.size(), ROWS_COUNT_INIT);
+
+	for (size_t r = 0; r < ROWS_COUNT_INIT; ++r) {
+		EXPECT_EQ(vectors[r].size(), COLS_COUNT_INIT);
+		for (size_t c = 0; c < COLS_COUNT_INIT; ++c) {
+			EXPECT_EQ(vectors[r][c], vec.element(r, c));
+		}
+	}
+}
+
+TEST_F(Vector2DTest, plainVector_returns_underlying_storage) {
+	const auto & plain = vec.asPlainVector();
+	EXPECT_EQ(plain.size(), vec.size());
+
+	for (size_t i = 0; i < plain.size(); ++i) {
+		EXPECT_EQ(plain[i], vec.asPlainVector()[i]);
+	}
+}
+
+TEST_F(Vector2DTest, toPlainVector_returns_copy) {
+	auto copy = vec.toPlainVector();
+	EXPECT_EQ(copy.size(), vec.size());
+	EXPECT_NE(copy.data(), vec.data()); // Different memory
+
+	for (size_t i = 0; i < copy.size(); ++i) {
+		EXPECT_EQ(copy[i], vec.asPlainVector()[i]);
+	}
+}
+
+// ==================== SWAP TESTS ====================
+TEST_F(Vector2DTest, swap_exchanges_contents) {
+	PIVector2D<int> other(5, 5, 42);
+
+	size_t oldRows        = vec.rows();
+	size_t oldCols        = vec.cols();
+	PIVector<int> oldData = vec.asPlainVector();
+
+	vec.swap(other);
+
+	EXPECT_EQ(vec.rows(), 5);
+	EXPECT_EQ(vec.cols(), 5);
+	for (size_t i = 0; i < vec.size(); ++i) {
+		EXPECT_EQ(vec.asPlainVector()[i], 42);
+	}
+
+	EXPECT_EQ(other.rows(), oldRows);
+	EXPECT_EQ(other.cols(), oldCols);
+	EXPECT_EQ(other.asPlainVector(), oldData);
+}
+
+// ==================== CLEAR TESTS ====================
+TEST_F(Vector2DTest, clear_removes_all_elements) {
+	vec.clear();
+	EXPECT_TRUE(vec.isEmpty());
+	EXPECT_EQ(vec.rows(), 0);
+	EXPECT_EQ(vec.cols(), 0);
+	EXPECT_EQ(vec.size(), 0);
+}
+
+// ==================== TRANSPOSE AND REVERSE TESTS ====================
+TEST_F(Vector2DTest, transposed_returns_correct_dimensions) {
+	auto transposed = vec.transposed();
+	EXPECT_EQ(transposed.rows(), COLS_COUNT_INIT);
+	EXPECT_EQ(transposed.cols(), ROWS_COUNT_INIT);
+
+	for (size_t r = 0; r < ROWS_COUNT_INIT; ++r) {
+		for (size_t c = 0; c < COLS_COUNT_INIT; ++c) {
+			EXPECT_EQ(transposed.element(c, r), vec.element(r, c));
+		}
+	}
+}
+
+TEST(Vector2DTransposeTest, emptyMatrix_returnsEmpty) {
+	PIVector2D<int> empty;
+	auto transposed = empty.transposed();
+	EXPECT_TRUE(transposed.isEmpty());
+	EXPECT_EQ(transposed.rows(), 0);
+	EXPECT_EQ(transposed.cols(), 0);
+}
+
+TEST(Vector2DTransposeTest, singleElement_returnsSame) {
+	PIVector2D<int> single(1, 1, 42);
+	auto transposed = single.transposed();
+	EXPECT_EQ(transposed.rows(), 1);
+	EXPECT_EQ(transposed.cols(), 1);
+	EXPECT_EQ(transposed.element(0, 0), 42);
+}
+
+TEST(Vector2DTransposeTest, oneRow_becomesOneColumn) {
+	PIVector2D<int> rowVec(1, 5);
+	for (size_t c = 0; c < 5; ++c)
+		rowVec.element(0, c) = static_cast<int>(c);
+	auto transposed = rowVec.transposed();
+	EXPECT_EQ(transposed.rows(), 5);
+	EXPECT_EQ(transposed.cols(), 1);
+	for (size_t r = 0; r < 5; ++r) {
+		EXPECT_EQ(transposed.element(r, 0), static_cast<int>(r));
+	}
+}
+
+TEST(Vector2DTransposeTest, oneColumn_becomesOneRow) {
+	PIVector2D<int> colVec(5, 1);
+	for (size_t r = 0; r < 5; ++r)
+		colVec.element(r, 0) = static_cast<int>(r);
+	auto transposed = colVec.transposed();
+	EXPECT_EQ(transposed.rows(), 1);
+	EXPECT_EQ(transposed.cols(), 5);
+	for (size_t c = 0; c < 5; ++c) {
+		EXPECT_EQ(transposed.element(0, c), static_cast<int>(c));
+	}
+}
+
+TEST_F(Vector2DTest, transposed_doesNotModifyOriginal) {
+	auto original   = vec; // копия для сравнения
+	auto transposed = vec.transposed();
+	// Проверяем, что исходный массив не изменился
+	EXPECT_EQ(vec, original);
+}
+
+TEST_F(Vector2DTest, reverseRows_reverses_row_order) {
+	auto original = vec;
+	vec.reverseRows();
+
+	for (size_t r = 0; r < ROWS_COUNT_INIT; ++r) {
+		for (size_t c = 0; c < COLS_COUNT_INIT; ++c) {
+			EXPECT_EQ(vec.element(r, c), original.element(ROWS_COUNT_INIT - 1 - r, c));
+		}
+	}
+}
+
+TEST_F(Vector2DTest, reverseColumns_reverses_column_order_in_each_row) {
+	auto original = vec;
+	vec.reverseColumns();
+
+	for (size_t r = 0; r < ROWS_COUNT_INIT; ++r) {
+		for (size_t c = 0; c < COLS_COUNT_INIT; ++c) {
+			EXPECT_EQ(vec.element(r, c), original.element(r, COLS_COUNT_INIT - 1 - c));
+		}
+	}
+}
+
+TEST_F(Vector2DTest, reverseRows_and_reverseColumns_compose_correctly) {
+	auto original = vec;
+	vec.reverseRows();
+	vec.reverseColumns();
+
+	// This should be equivalent to 180-degree rotation
+	for (size_t r = 0; r < ROWS_COUNT_INIT; ++r) {
+		for (size_t c = 0; c < COLS_COUNT_INIT; ++c) {
+			EXPECT_EQ(vec.element(r, c), original.element(ROWS_COUNT_INIT - 1 - r, COLS_COUNT_INIT - 1 - c));
+		}
+	}
+}
+
+// ==================== RANGE TESTS ====================
+TEST_F(Vector2DTest, getRange_returns_submatrix) {
+	auto sub = vec.getRange(5, 10, 8, 15);
+	EXPECT_EQ(sub.rows(), 10);
+	EXPECT_EQ(sub.cols(), 15);
+
+	for (size_t r = 0; r < 10; ++r) {
+		for (size_t c = 0; c < 15; ++c) {
+			EXPECT_EQ(sub.element(r, c), vec.element(5 + r, 8 + c));
+		}
+	}
+}
+
+TEST_F(Vector2DTest, getRange_with_invalid_params_returns_empty) {
+	auto sub1 = vec.getRange(ROWS_COUNT_INIT, 5, 0, 5);
+	EXPECT_TRUE(sub1.isEmpty());
+
+	auto sub2 = vec.getRange(0, 5, COLS_COUNT_INIT, 5);
+	EXPECT_TRUE(sub2.isEmpty());
+}
+
+TEST_F(Vector2DTest, getRange_truncates_out_of_bounds) {
+	auto sub = vec.getRange(ROWS_COUNT_INIT - 5, 10, COLS_COUNT_INIT - 5, 10);
+	EXPECT_EQ(sub.rows(), 5);
+	EXPECT_EQ(sub.cols(), 5);
+}
+
+// ==================== FUNCTIONAL PROGRAMMING TESTS ====================
+TEST_F(Vector2DTest, map_transforms_elements) {
+	auto doubled = vec.map<int>([](const int & e) { return e * 2; });
+	EXPECT_EQ(doubled.rows(), vec.rows());
+	EXPECT_EQ(doubled.cols(), vec.cols());
+
+	for (size_t r = 0; r < vec.rows(); ++r) {
+		for (size_t c = 0; c < vec.cols(); ++c) {
+			EXPECT_EQ(doubled.element(r, c), vec.element(r, c) * 2);
+		}
+	}
+}
+
+TEST_F(Vector2DTest, map_changes_type) {
+	auto asString = vec.map<PIString>([](const int & e) { return PIString::fromNumber(e); });
+	EXPECT_EQ(asString.rows(), vec.rows());
+	EXPECT_EQ(asString.cols(), vec.cols());
+
+	for (size_t r = 0; r < vec.rows(); ++r) {
+		for (size_t c = 0; c < vec.cols(); ++c) {
+			EXPECT_EQ(asString.element(r, c), PIString::fromNumber(vec.element(r, c)));
+		}
+	}
+}
+
+TEST_F(Vector2DTest, mapIndexed_uses_indices) {
+	auto indexed = vec.mapIndexed<int>([](size_t r, size_t c, const int & e) { return static_cast<int>(r * 1000 + c); });
+
+	for (size_t r = 0; r < vec.rows(); ++r) {
+		for (size_t c = 0; c < vec.cols(); ++c) {
+			EXPECT_EQ(indexed.element(r, c), static_cast<int>(r * 1000 + c));
+		}
+	}
+}
+
+TEST_F(Vector2DTest, forEach_readonly_visits_all_elements) {
+	size_t count = 0;
+	vec.asPlainVector().forEach([&count](const int &) { count++; });
+	EXPECT_EQ(count, vec.size());
+}
+
+TEST_F(Vector2DTest, forEach_modifying_changes_elements) {
+	vec.asPlainVector().forEach([](int & e) { e++; });
+
+	for (size_t r = 0; r < ROWS_COUNT_INIT; ++r) {
+		for (size_t c = 0; c < COLS_COUNT_INIT; ++c) {
+			EXPECT_EQ(vec.element(r, c), r * COLS_COUNT_INIT + c + 1);
+		}
+	}
+}
+
+TEST_F(Vector2DTest, indexOf_returns_correct_pair) {
+	auto p = vec.indexOf(vec.element(10, 15));
+	EXPECT_EQ(p.row, 10);
+	EXPECT_EQ(p.col, 15);
+	p = vec.indexOf(-999);
+	EXPECT_EQ(p.row, -1);
+	EXPECT_EQ(p.col, -1);
+}
+
+TEST_F(Vector2DTest, indexWhere_returns_correct_pair) {
+	vec.element(5, 5) = -42;
+	auto isTarget     = [](const int & e) { return e == -42; };
+	auto p            = vec.indexWhere(isTarget);
+	EXPECT_EQ(p.row, 5);
+	EXPECT_EQ(p.col, 5);
+}
+
+TEST_F(Vector2DTest, lastIndexOf_works) {
+	int val             = vec.element(10, 10);
+	vec.element(20, 20) = val; // duplicate
+	auto p              = vec.lastIndexOf(val);
+	EXPECT_EQ(p.row, 20);
+	EXPECT_EQ(p.col, 20);
+}
+
+TEST_F(Vector2DTest, lastIndexWhere_works) {
+	auto isLarge = [](const int & e) { return e > 500; };
+	auto p       = vec.lastIndexWhere(isLarge);
+	EXPECT_GE(p.row, 0);
+	EXPECT_GE(p.col, 0);
+	// The last element with value >500 should be the largest index
+	size_t lastFlat         = p.row * vec.cols() + p.col;
+	size_t expectedLastFlat = vec.size() - 1;
+	EXPECT_EQ(lastFlat, expectedLastFlat);
+}
+
+TEST_F(Vector2DTest, reduce_accumulates_correctly) {
+	int sum      = vec.reduce<int>([](const int & e, const int & acc) { return e + acc; });
+
+	int expected = (vec.size() - 1) * vec.size() / 2;
+	EXPECT_EQ(sum, expected);
+}
+
+TEST_F(Vector2DTest, reduce_with_initial_value) {
+	int sum      = vec.reduce<int>([](const int & e, const int & acc) { return e + acc; }, 100);
+
+	int expected = (vec.size() - 1) * vec.size() / 2 + 100;
+	EXPECT_EQ(sum, expected);
+}
+
+TEST_F(Vector2DTest, reduceIndexed_uses_indices) {
+	int sum =
+		vec.reduceIndexed<int>([](size_t r, size_t c, const int & e, const int & acc) { return acc + static_cast<int>(r * 1000 + c); });
+
+	int expected = 0;
+	for (size_t r = 0; r < ROWS_COUNT_INIT; ++r) {
+		for (size_t c = 0; c < COLS_COUNT_INIT; ++c) {
+			expected += r * 1000 + c;
+		}
+	}
+	EXPECT_EQ(sum, expected);
+}
+
+// ==================== REMOVAL TESTS ====================
+TEST_F(Vector2DTest, removeRow_removes_specified_row) {
+	size_t oldRows  = vec.rows();
+	auto rowContent = vec[10].toVector();
+
+	vec.removeRow(10);
+	EXPECT_EQ(vec.rows(), oldRows - 1);
+
+	// Check rows after 10 shifted up
+	for (size_t r = 10; r < vec.rows(); ++r) {
+		for (size_t c = 0; c < vec.cols(); ++c) {
+			EXPECT_EQ(vec.element(r, c), (r + 1) * COLS_COUNT_INIT + c);
+		}
+	}
+}
+
+TEST_F(Vector2DTest, removeRow_invalid_index_does_nothing) {
+	size_t oldRows = vec.rows();
+	vec.removeRow(ROWS_COUNT_INIT + 10);
+	EXPECT_EQ(vec.rows(), oldRows);
+}
+
+TEST_F(Vector2DTest, removeRow_last_row_works) {
+	size_t oldRows = vec.rows();
+	vec.removeRow(oldRows - 1);
+	EXPECT_EQ(vec.rows(), oldRows - 1);
+}
+
+TEST_F(Vector2DTest, removeColumn_removes_specified_column) {
+	size_t oldCols = vec.cols();
+	vec.removeColumn(15);
+	EXPECT_EQ(vec.cols(), oldCols - 1);
+
+	for (size_t r = 0; r < vec.rows(); ++r) {
+		for (size_t c = 0; c < 15; ++c) {
+			EXPECT_EQ(vec.element(r, c), r * COLS_COUNT_INIT + c);
+		}
+		for (size_t c = 15; c < vec.cols(); ++c) {
+			EXPECT_EQ(vec.element(r, c), r * COLS_COUNT_INIT + c + 1);
+		}
+	}
+}
+
+TEST_F(Vector2DTest, removeColumn_invalid_index_does_nothing) {
+	size_t oldCols = vec.cols();
+	vec.removeColumn(COLS_COUNT_INIT + 10);
+	EXPECT_EQ(vec.cols(), oldCols);
+}
+
+TEST_F(Vector2DTest, removeColumn_last_column_works) {
+	size_t oldCols = vec.cols();
+	vec.removeColumn(oldCols - 1);
+	EXPECT_EQ(vec.cols(), oldCols - 1);
+}
+
+TEST_F(Vector2DTest, removeRowsWhere_removes_matching_rows) {
+	auto isSpecial = [](const PIVector2D<int>::RowConst & row) {
+		return row[0] == 999; // First element is 999
+	};
+
+	const size_t rowsCont = 5;
+	// Add some identifiable rows
+	for (size_t r = 0; r < rowsCont; ++r) {
+		vec.addRow(PIVector<int>(COLS_COUNT_INIT, 999));
+	}
+	EXPECT_EQ(vec.filterRows(isSpecial).rows(), rowsCont);
+
+	vec.removeRowsWhere(isSpecial);
+	EXPECT_EQ(vec.rows(), ROWS_COUNT_INIT);
+
+	// Verify no rows with 999 remain
+	auto res = vec.filterRows(isSpecial);
+	EXPECT_TRUE(res.isEmpty());
+}
+
+TEST_F(Vector2DTest, removeColumnsWhere_removes_matching_columns) {
+	// Make some columns have a distinctive first element
+	for (size_t c = 0; c < 5; ++c) {
+		vec.element(0, c) = 777;
+	}
+
+	auto isSpecial = [](const PIVector2D<int>::ColConst & col) {
+		return col[0] == 777; // First element is 777
+	};
+
+	size_t oldCols = vec.cols();
+	vec.removeColumnsWhere(isSpecial);
+	EXPECT_EQ(vec.cols(), oldCols - 5);
+
+	// Verify no columns with 777 in first row remain
+	for (size_t c = 0; c < vec.cols(); ++c) {
+		EXPECT_NE(vec.element(0, c), 777);
+	}
+}
+
+// ==================== FILTER TESTS ====================
+TEST_F(Vector2DTest, filterRows_returns_only_matching_rows) {
+	auto rowsWithEvenFirst = vec.filterRows([](const PIVector2D<int>::RowConst & row) { return row[0] % 2 == 0; });
+
+	// First element of row r is r * COLS_COUNT_INIT
+	// This is even for all rows since COLS_COUNT_INIT is even (34)
+	EXPECT_EQ(rowsWithEvenFirst.rows(), ROWS_COUNT_INIT);
+
+	auto rowsWithLargeFirst = vec.filterRows([](const PIVector2D<int>::RowConst & row) { return row[0] > 500; });
+
+	// First element > 500 means r * 34 > 500 -> r > 14.7
+	EXPECT_EQ(rowsWithLargeFirst.rows(), ROWS_COUNT_INIT - 15);
+}
+
+TEST_F(Vector2DTest, filterColumns_returns_only_matching_columns) {
+	auto colsWithEvenFirst = vec.filterColumns([](const PIVector2D<int>::ColConst & col) { return col[0] % 2 == 0; });
+
+	// First element of column c is c
+	EXPECT_EQ(colsWithEvenFirst.cols(), COLS_COUNT_INIT / 2);
+}
+
+TEST_F(Vector2DTest, filterColumns_empty_result_returns_empty) {
+	auto noCols = vec.filterColumns([](const PIVector2D<int>::ColConst &) { return false; });
+	EXPECT_TRUE(noCols.isEmpty());
+}
+
+// ==================== EDGE CASE TESTS ====================
+TEST(Vector2DEdgeTest, empty_vector_operations) {
+	PIVector2D<int> empty;
+
+	EXPECT_TRUE(empty.isEmpty());
+	EXPECT_EQ(empty.rows(), 0);
+	EXPECT_EQ(empty.cols(), 0);
+
+	// These should not crash
+	empty.clear();
+	empty.fill(42);
+	empty.transposed();
+	empty.reverseRows();
+	empty.reverseColumns();
+
+	auto range = empty.getRange(0, 5, 0, 5);
+	EXPECT_TRUE(range.isEmpty());
+
+	auto filtered = empty.filterRows([](const PIVector2D<int>::RowConst &) { return true; });
+	EXPECT_TRUE(filtered.isEmpty());
+}
+
+TEST(Vector2DEdgeTest, single_element_vector) {
+	PIVector2D<int> single(1, 1, 42);
+
+	EXPECT_EQ(single.rows(), 1);
+	EXPECT_EQ(single.cols(), 1);
+	EXPECT_EQ(single.element(0, 0), 42);
+
+	auto row = single[0];
+	EXPECT_EQ(row.size(), 1);
+	EXPECT_EQ(row[0], 42);
+
+	auto col = single.col(0);
+	EXPECT_EQ(col.size(), 1);
+	EXPECT_EQ(col[0], 42);
+
+	single.reverseRows(); // Should do nothing
+	EXPECT_EQ(single.element(0, 0), 42);
+
+	single.reverseColumns(); // Should do nothing
+	EXPECT_EQ(single.element(0, 0), 42);
+}
+
+// ==================== PROXY ADDITIONAL OPERATIONS TESTS ====================
+TEST_F(Vector2DTest, row_proxy_forEach_modifies_elements) {
+	auto row = vec[5];
+	row.forEach([](int & e) { e += 100; });
+	for (size_t c = 0; c < COLS_COUNT_INIT; ++c) {
+		EXPECT_EQ(vec.element(5, c), 5 * COLS_COUNT_INIT + c + 100);
+	}
+}
+
+TEST_F(Vector2DTest, row_proxy_forEach_const_iterates) {
+	const auto & constVec = vec;
+	auto row              = constVec[5];
+	size_t count          = 0;
+	row.forEach([&count](const int &) { ++count; });
+	EXPECT_EQ(count, COLS_COUNT_INIT);
+}
+
+TEST_F(Vector2DTest, row_proxy_fill_sets_all_elements) {
+	auto row = vec[12];
+	row.fill(999);
+	for (size_t c = 0; c < COLS_COUNT_INIT; ++c) {
+		EXPECT_EQ(vec.element(12, c), 999);
+	}
+}
+
+TEST_F(Vector2DTest, row_proxy_contains_finds_element) {
+	auto row = vec[8];
+	EXPECT_TRUE(row.contains(vec.element(8, 10)));
+	EXPECT_FALSE(row.contains(-999));
+}
+
+TEST_F(Vector2DTest, row_proxy_entries_counts_occurrences) {
+	auto row            = vec[15];
+	// Add a duplicate
+	int val             = vec.element(15, 5);
+	vec.element(15, 20) = val;
+	EXPECT_EQ(row.entries(val), 2);
+	EXPECT_EQ(row.entries(-999), 0);
+}
+
+TEST_F(Vector2DTest, row_proxy_entries_with_predicate_counts_matches) {
+	auto row     = vec[20];
+	auto isEven  = [](const int & e) { return e % 2 == 0; };
+	int expected = 0;
+	for (size_t c = 0; c < COLS_COUNT_INIT; ++c) {
+		if (row[c] % 2 == 0) ++expected;
+	}
+	EXPECT_EQ(row.entries(isEven), expected);
+}
+
+TEST_F(Vector2DTest, row_proxy_any_returns_true_if_any_match) {
+	auto row        = vec[25];
+	auto isNegative = [](const int & e) { return e < 0; };
+	EXPECT_FALSE(row.any(isNegative));
+	auto isPositive = [](const int & e) { return e >= 0; };
+	EXPECT_TRUE(row.any(isPositive));
+}
+
+TEST_F(Vector2DTest, row_proxy_every_returns_true_if_all_match) {
+	auto row           = vec[30];
+	auto isLessThanMax = [&](const int & e) { return e < static_cast<int>(vec.size()); };
+	EXPECT_TRUE(row.every(isLessThanMax));
+	auto isEven = [](const int & e) { return e % 2 == 0; };
+	EXPECT_FALSE(row.every(isEven));
+}
+
+// ----------------------------------------------------------------------------
+TEST_F(Vector2DTest, col_proxy_forEach_modifies_elements) {
+	auto col = vec.col(7);
+	col.forEach([](int & e) { e += 50; });
+	for (size_t r = 0; r < ROWS_COUNT_INIT; ++r) {
+		EXPECT_EQ(vec.element(r, 7), r * COLS_COUNT_INIT + 7 + 50);
+	}
+}
+
+TEST_F(Vector2DTest, col_proxy_forEach_const_iterates) {
+	const auto & constVec = vec;
+	auto col              = constVec.col(9);
+	size_t count          = 0;
+	col.forEach([&count](const int &) { ++count; });
+	EXPECT_EQ(count, ROWS_COUNT_INIT);
+}
+
+TEST_F(Vector2DTest, col_proxy_fill_sets_all_elements) {
+	auto col = vec.col(11);
+	col.fill(777);
+	for (size_t r = 0; r < ROWS_COUNT_INIT; ++r) {
+		EXPECT_EQ(vec.element(r, 11), 777);
+	}
+}
+
+TEST_F(Vector2DTest, col_proxy_contains_finds_element) {
+	auto col = vec.col(13);
+	EXPECT_TRUE(col.contains(vec.element(5, 13)));
+	EXPECT_FALSE(col.contains(-999));
+}
+
+TEST_F(Vector2DTest, col_proxy_entries_counts_occurrences) {
+	auto col            = vec.col(17);
+	int val             = vec.element(3, 17);
+	vec.element(22, 17) = val; // duplicate
+	EXPECT_EQ(col.entries(val), 2);
+	EXPECT_EQ(col.entries(-999), 0);
+}
+
+TEST_F(Vector2DTest, col_proxy_entries_with_predicate_counts_matches) {
+	auto col     = vec.col(19);
+	auto isOdd   = [](const int & e) { return e % 2 != 0; };
+	int expected = 0;
+	for (size_t r = 0; r < ROWS_COUNT_INIT; ++r) {
+		if (col[r] % 2 != 0) ++expected;
+	}
+	EXPECT_EQ(col.entries(isOdd), expected);
+}
+
+TEST_F(Vector2DTest, col_proxy_any_returns_true_if_any_match) {
+	auto col        = vec.col(21);
+	auto isNegative = [](const int & e) { return e < 0; };
+	EXPECT_FALSE(col.any(isNegative));
+	auto isPositive = [](const int & e) { return e >= 0; };
+	EXPECT_TRUE(col.any(isPositive));
+}
+
+TEST_F(Vector2DTest, col_proxy_every_returns_true_if_all_match) {
+	auto col           = vec.col(23);
+	auto isLessThanMax = [&](const int & e) { return e < static_cast<int>(vec.size()); };
+	EXPECT_TRUE(col.every(isLessThanMax));
+	auto isEven = [](const int & e) { return e % 2 == 0; };
+	EXPECT_FALSE(col.every(isEven));
+}
+
+// ----------------------------------------------------------------------------
+TEST_F(Vector2DTest, rowconst_proxy_forEach_iterates) {
+	const auto & constVec = vec;
+	auto row              = constVec[5];
+	size_t count          = 0;
+	row.forEach([&count](const int &) { ++count; });
+	EXPECT_EQ(count, COLS_COUNT_INIT);
+}
+
+TEST_F(Vector2DTest, rowconst_proxy_contains_finds_element) {
+	const auto & constVec = vec;
+	auto row              = constVec[6];
+	EXPECT_TRUE(row.contains(vec.element(6, 10)));
+	EXPECT_FALSE(row.contains(-999));
+}
+
+TEST_F(Vector2DTest, rowconst_proxy_entries_counts_occurrences) {
+	const auto & constVec = vec;
+	auto row              = constVec[7];
+	int val               = vec.element(7, 5);
+	// We can't modify through const proxy, but duplicates already exist from previous tests
+	EXPECT_GE(row.entries(val), 1); // at least one
+}
+
+TEST_F(Vector2DTest, rowconst_proxy_entries_with_predicate_counts_matches) {
+	const auto & constVec = vec;
+	auto row              = constVec[9];
+	auto isEven           = [](const int & e) { return e % 2 == 0; };
+	int expected          = 0;
+	for (size_t c = 0; c < COLS_COUNT_INIT; ++c) {
+		if (vec.element(9, c) % 2 == 0) ++expected;
+	}
+	EXPECT_EQ(row.entries(isEven), expected);
+}
+
+TEST_F(Vector2DTest, rowconst_proxy_any_returns_true_if_any_match) {
+	const auto & constVec = vec;
+	auto row              = constVec[10];
+	auto isNegative       = [](const int & e) { return e < 0; };
+	EXPECT_FALSE(row.any(isNegative));
+	auto isPositive = [](const int & e) { return e >= 0; };
+	EXPECT_TRUE(row.any(isPositive));
+}
+
+TEST_F(Vector2DTest, rowconst_proxy_every_returns_true_if_all_match) {
+	const auto & constVec = vec;
+	auto row              = constVec[11];
+	auto isLessThanMax    = [&](const int & e) { return e < static_cast<int>(vec.size()); };
+	EXPECT_TRUE(row.every(isLessThanMax));
+	auto isEven = [](const int & e) { return e % 2 == 0; };
+	EXPECT_FALSE(row.every(isEven));
+}
+
+// ----------------------------------------------------------------------------
+TEST_F(Vector2DTest, colconst_proxy_forEach_iterates) {
+	const auto & constVec = vec;
+	auto col              = constVec.col(25);
+	size_t count          = 0;
+	col.forEach([&count](const int &) { ++count; });
+	EXPECT_EQ(count, ROWS_COUNT_INIT);
+}
+
+TEST_F(Vector2DTest, colconst_proxy_contains_finds_element) {
+	const auto & constVec = vec;
+	auto col              = constVec.col(27);
+	EXPECT_TRUE(col.contains(vec.element(4, 27)));
+	EXPECT_FALSE(col.contains(-999));
+}
+
+TEST_F(Vector2DTest, colconst_proxy_entries_counts_occurrences) {
+	const auto & constVec = vec;
+	auto col              = constVec.col(29);
+	int val               = vec.element(8, 29);
+	EXPECT_GE(col.entries(val), 1);
+}
+
+TEST_F(Vector2DTest, colconst_proxy_entries_with_predicate_counts_matches) {
+	const auto & constVec = vec;
+	auto col              = constVec.col(31);
+	auto isOdd            = [](const int & e) { return e % 2 != 0; };
+	int expected          = 0;
+	for (size_t r = 0; r < ROWS_COUNT_INIT; ++r) {
+		if (vec.element(r, 31) % 2 != 0) ++expected;
+	}
+	EXPECT_EQ(col.entries(isOdd), expected);
+}
+
+TEST_F(Vector2DTest, colconst_proxy_any_returns_true_if_any_match) {
+	const auto & constVec = vec;
+	auto col              = constVec.col(33);
+	auto isNegative       = [](const int & e) { return e < 0; };
+	EXPECT_FALSE(col.any(isNegative));
+	auto isPositive = [](const int & e) { return e >= 0; };
+	EXPECT_TRUE(col.any(isPositive));
+}
+
+TEST_F(Vector2DTest, colconst_proxy_every_returns_true_if_all_match) {
+	const auto & constVec = vec;
+	auto col              = constVec.col(0);
+	auto isLessThanMax    = [&](const int & e) { return e < static_cast<int>(vec.size()); };
+	EXPECT_TRUE(col.every(isLessThanMax));
+	auto isNotEven = [](const int & e) { return e % 2 != 0; };
+	EXPECT_FALSE(col.every(isNotEven));
+}
+
+// ==================== OUTPUT TESTS ====================
+TEST_F(Vector2DTest, picout_operator_works) {
+	// Just test that it compiles and doesn't crash
+	PICout s;
+	s << vec;
+	// No assertion, just ensure it runs
+}
+
+#ifdef PIP_STD_IOSTREAM
+TEST_F(Vector2DTest, iostream_operator_works) {
+	// PIVector2D doesn't have direct iostream operator,
+	// but PIVector does, and we can test conversion
+	std::stringstream ss;
+	ss << vec.plainVector();
+	// No assertion, just ensure it runs
+}
+#endif
+
+// ==================== INDEX STRUCTURE ACCESS TESTS ====================
+TEST_F(Vector2DTest, operator_bracket_with_index_allows_read_access) {
+	PIVector2D<int>::Index idx = {5, 7};
+	int value                  = vec[idx];
+	int expected               = vec.element(5, 7);
+	EXPECT_EQ(value, expected);
+}
+
+TEST_F(Vector2DTest, operator_bracket_with_index_allows_write_access) {
+	PIVector2D<int>::Index idx = {10, 15};
+	vec[idx]                   = 999;
+	EXPECT_EQ(vec.element(10, 15), 999);
+}
+
+TEST_F(Vector2DTest, operator_bracket_with_const_index_works) {
+	const auto & constVec      = vec;
+	PIVector2D<int>::Index idx = {3, 12};
+	int value                  = constVec[idx];
+	int expected               = vec.element(3, 12);
+	EXPECT_EQ(value, expected);
+}
+
+TEST_F(Vector2DTest, element_function_with_index_works) {
+	PIVector2D<int>::Index idx = {8, 20};
+	int value                  = vec.element(idx);
+	int expected               = vec.element(8, 20);
+	EXPECT_EQ(value, expected);
+}
+
+TEST_F(Vector2DTest, element_function_with_index_modifies_value) {
+	PIVector2D<int>::Index idx = {12, 8};
+	vec.element(idx)           = 555;
+	EXPECT_EQ(vec.element(12, 8), 555);
+}
+
+TEST_F(Vector2DTest, element_function_with_const_index_works) {
+	const auto & constVec      = vec;
+	PIVector2D<int>::Index idx = {7, 5};
+	int value                  = constVec.element(idx);
+	int expected               = vec.element(7, 5);
+	EXPECT_EQ(value, expected);
+}
+
+TEST_F(Vector2DTest, at_function_with_index_works) {
+	PIVector2D<int>::Index idx = {4, 11};
+	int value                  = vec.at(idx);
+	int expected               = vec.at(4, 11);
+	EXPECT_EQ(value, expected);
+}
+
+TEST_F(Vector2DTest, index_structure_with_brace_initialization_works) {
+	vec[{0, 0}] = 100;
+	EXPECT_EQ(vec.element(0, 0), 100);
+
+	vec[{static_cast<ssize_t>(ROWS_COUNT_INIT - 1), static_cast<ssize_t>(COLS_COUNT_INIT - 1)}] = 200;
+	EXPECT_EQ(vec.element(ROWS_COUNT_INIT - 1, COLS_COUNT_INIT - 1), 200);
+}
+
+TEST(Vector2DIndexTest, default_constructor_initializes_to_invalid) {
+	PIVector2D<int>::Index idx;
+	EXPECT_TRUE(idx.isNotValid());
+	EXPECT_FALSE(idx.isValid());
+	EXPECT_EQ(idx.row, -1);
+	EXPECT_EQ(idx.col, -1);
+}
+
+TEST(Vector2DIndexTest, parameterized_constructor_initializes_correctly) {
+	PIVector2D<int>::Index idx(5, 10);
+	EXPECT_TRUE(idx.isValid());
+	EXPECT_FALSE(idx.isNotValid());
+	EXPECT_EQ(idx.row, 5);
+	EXPECT_EQ(idx.col, 10);
+}
+
+TEST(Vector2DIndexTest, isValid_returns_true_for_non_negative_values) {
+	PIVector2D<int>::Index idx(0, 0);
+	EXPECT_TRUE(idx.isValid());
+	EXPECT_FALSE(idx.isNotValid());
+}
+
+TEST(Vector2DIndexTest, isNotValid_returns_true_for_negative_values) {
+	PIVector2D<int>::Index idx1;
+	EXPECT_TRUE(idx1.isNotValid());
+
+	PIVector2D<int>::Index idx2(-1, 5);
+	EXPECT_TRUE(idx2.isNotValid());
+
+	PIVector2D<int>::Index idx3(5, -1);
+	EXPECT_TRUE(idx3.isNotValid());
 }

utils/value_tree_translator/main.cpp

@@ -72,7 +72,7 @@ const PIString contextName = "QAD::PIValueTreeEdit";
 
 
 void gatherStrings(TSFile::Context & context, const PIValueTree & vt, const PIString & loc) {
-	const static PIStringList attrs({Attribute::prefix, Attribute::suffix});
+	const static PIStringList attrs({Attribute::prefix, Attribute::suffix, Attribute::toolTip});
 	for (const auto & c: vt.children()) {
 		context.confirm(c.name(), loc);
 		context.confirm(c.comment(), loc);