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

Compare commits

base: SHS:98d93865f0811c3f5ac85b36cd5262ff3ff9fd72
Branches Tags
SHS:master SHS:mqtt_client SHS:pico_sdk SHS:inactive/zmq SHS:archive/old
..
compare: SHS:pico_sdk
Branches Tags
SHS:master SHS:mqtt_client SHS:pico_sdk SHS:inactive/zmq SHS:archive/old

3 Commits
98d93865f0 ... pico_sdk

Author SHA1 Message Date
Andrey Bychkov
c60a682279 missing include 2026-01-02 20:48:37 +03:00
Andrey Bychkov
cf89d77981 pip micro disable piintrospection piwaitevent 
PIP_NO_SOCET
 2025-10-18 11:20:18 +03:00
Andrey Bychkov
4885623492 Add pico sdk define 2025-10-18 08:53:47 +03:00
30 changed files with 682 additions and 3258 deletions
Expand all files Collapse all files

35
CMakeLists.txt
View File

@@ -6,7 +6,7 @@ endif()
project(PIP)
set(PIP_MAJOR 5)
set(PIP_MINOR 5)
set(PIP_REVISION 5)
set(PIP_REVISION 2)
set(PIP_SUFFIX )
set(PIP_COMPANY SHS)
set(PIP_DOMAIN org.SHS)
@@ -221,11 +221,18 @@ if (TESTS)
add_subdirectory(tests)
endif()
if(PIP_FREERTOS)
add_definitions(-DPIP_FREERTOS)
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}")
endif()
# Check Bessel functions
set(CMAKE_REQUIRED_INCLUDES math.h)
@@ -329,7 +336,7 @@ if ((NOT DEFINED SHSTKPROJECT) AND (DEFINED ANDROID_PLATFORM))
#message("${ANDROID_NDK}/sysroot/usr/include")
endif()
if(NOT PIP_FREERTOS)
if(NOT PIP_MICRO)
if(WIN32)
if(${C_COMPILER} STREQUAL "cl.exe")
else()
@@ -350,7 +357,7 @@ if(NOT PIP_FREERTOS)
endif()
endif()
set(PIP_LIBS)
if(PIP_FREERTOS)
if(PIP_MICRO)
set(PIP_LIBS ${LIBS_MAIN})
else()
foreach(LIB_ ${LIBS_MAIN})
@@ -364,11 +371,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 )
@@ -406,7 +413,7 @@ endif()
if (NOT CROSSTOOLS)
if (NOT PIP_FREERTOS)
if (NOT PIP_MICRO)
if (PIP_BUILD_CONSOLE)
pip_module(console "" "PIP console support" "" "" "")
@@ -624,7 +631,7 @@ string(REPLACE ";" "," PIP_EXPORTS_STR "${PIP_EXPORTS}")
target_compile_definitions(pip PRIVATE "PICODE_DEFINES=\"${PIP_EXPORTS_STR}\"")
if(NOT PIP_FREERTOS)
if(NOT PIP_MICRO)
# Auxiliary
if (NOT CROSSTOOLS)
@@ -701,7 +708,7 @@ if(NOT LOCAL)
install(TARGETS ${PIP_MODULES} DESTINATION ${CMAKE_INSTALL_PREFIX}/lib)
endif()
else()
if(NOT PIP_FREERTOS)
if(NOT PIP_MICRO)
if(WIN32)
install(TARGETS ${PIP_MODULES} RUNTIME DESTINATION bin)
install(TARGETS ${PIP_MODULES} ARCHIVE DESTINATION lib)
@@ -729,7 +736,7 @@ endif()
#
# Build Documentation
#
if ((NOT PIP_FREERTOS) AND (NOT CROSSTOOLS))
if ((NOT PIP_MICRO) AND (NOT CROSSTOOLS))
include(PIPDocumentation)
find_package(Doxygen)
if(DOXYGEN_FOUND)
@@ -798,7 +805,7 @@ message(" Type : ${CMAKE_BUILD_TYPE}")
if (NOT LOCAL)
message(" Install: \"${CMAKE_INSTALL_PREFIX}\"")
else()
if(NOT PIP_FREERTOS)
if(NOT PIP_MICRO)
message(" Install: local \"bin\", \"lib\" and \"include\"")
endif()
endif()
@@ -831,7 +838,7 @@ message(" Utilites:")
foreach(_util ${PIP_UTILS_LIST})
message(" * ${_util}")
endforeach()
if(NOT PIP_FREERTOS)
if(NOT PIP_MICRO)
message("")
message(" Using libraries:")
foreach(LIB_ ${LIBS_STATUS})

2
cmake/FindPIP.cmake
View File

@@ -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_FREERTOS))
if((NOT DEFINED ENV{QNX_HOST}) AND (NOT APPLE) AND (NOT PIP_MICRO))
find_library(RT_LIBRARY rt)
list(APPEND _PIP_ADD_LIBS_ ${RT_LIBRARY})
endif()

1
esp-pip/CMakeLists.txt
View File

@@ -17,6 +17,7 @@ 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)

2
libs/http_client/pihttpclient.cpp
View File

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

28
libs/main/application/pisystemmonitor.cpp
View File

@@ -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,6 +178,9 @@ 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();
@@ -185,16 +188,14 @@ void PISystemMonitor::run() {
if (t->isPIObject()) tbid[t->tid()] = t->name();
pitc->unlock();
// piCout << tbid.keys().toType<uint>();
ProcessStats tstat;
tstat.ID = pID_;
#ifdef MICRO_PIP
# ifdef FREERTOS
for (auto * t: tv)
if (t->isPIObject()) gatherThread(t->tid());
#else
# ifndef WINDOWS
# else // FREERTOS
# 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]);
@@ -210,7 +211,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
# else // MAC_OS
PRIVATE->file.seekToBegin();
PIString str = PIString::fromAscii(PRIVATE->file.readAll());
int si = str.find('(') + 1, fi = 0, cc = 1;
@@ -264,8 +265,8 @@ void PISystemMonitor::run() {
if (i.flags[PIFile::FileInfo::Dot] || i.flags[PIFile::FileInfo::DotDot]) continue;
gatherThread(i.name().toInt());
}
# endif
# else
# endif // MAC_OS
# else // WINDOWS
if (GetProcessMemoryInfo(PRIVATE->hProc, &PRIVATE->mem_cnt, sizeof(PRIVATE->mem_cnt)) != 0) {
tstat.physical_memsize = PRIVATE->mem_cnt.WorkingSetSize;
}
@@ -315,8 +316,9 @@ void PISystemMonitor::run() {
tstat.cpu_load_user = 0.f;
}
PRIVATE->tm.reset();
# endif
#endif
# endif // WINDOWS
# endif // FREERTOS
#endif // PIP_NO_THREADS
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);
@@ -352,7 +354,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();

66
libs/main/console/pikbdlistener.cpp
View File

@@ -18,9 +18,11 @@
*/
#include "pikbdlistener.h"
#include "piincludes_p.h"
#include "piliterals.h"
#include "piwaitevent_p.h"
#ifndef MICRO_PIP
# include "piincludes_p.h"
# include "piliterals.h"
# include "piwaitevent_p.h"
// clang-format off
#ifndef WINDOWS
# include <termios.h>
@@ -49,7 +51,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},
@@ -130,22 +132,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)
@@ -154,13 +156,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;
@@ -178,10 +180,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);
@@ -189,11 +191,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);
@@ -214,7 +216,7 @@ PIKbdListener::MouseButtons getButtons(DWORD v) {
if (v & FROM_LEFT_2ND_BUTTON_PRESSED) ret |= PIKbdListener::MouseMiddle;
return ret;
}
#endif
# endif
void PIKbdListener::readKeyboard() {
@@ -222,7 +224,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) {
@@ -406,7 +408,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);
@@ -533,7 +535,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;
@@ -560,30 +562,32 @@ 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

25
libs/main/console/pikbdlistener.h
View File

@@ -26,15 +26,19 @@
#ifndef PIKBDLISTENER_H
#define PIKBDLISTENER_H
#include "pithread.h"
#include "pitime.h"
#include "pibase.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(); \
}
#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(); \
}
class PIP_EXPORT PIKbdListener: public PIThread {
@@ -231,7 +235,7 @@ private:
void run() override { readKeyboard(); }
void end() override;
#ifndef WINDOWS
# ifndef WINDOWS
struct PIP_EXPORT EscSeq {
const char * seq;
int key;
@@ -251,7 +255,7 @@ private:
};
static const EscSeq esc_seq[];
#endif
# endif
PRIVATE_DECLARATION(PIP_EXPORT)
KBFunc ret_func;
@@ -305,4 +309,5 @@ REGISTER_PIVARIANTSIMPLE(PIKbdListener::KeyEvent)
REGISTER_PIVARIANTSIMPLE(PIKbdListener::MouseEvent)
REGISTER_PIVARIANTSIMPLE(PIKbdListener::WheelEvent)
#endif // MICRO_PIP
#endif // PIKBDLISTENER_H

30
libs/main/containers/pivector.h
View File

@@ -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(), \a contains()
inline bool containsAll(const PIVector<T> & v, ssize_t start = 0) const {
//! \~\sa \a every(), \a any(), \a entries(), \a forEach()
inline bool contains(const PIVector<T> & v, ssize_t start = 0) const {
if (start < 0) {
start = piv_size + start;
if (start < 0) start = 0;
@@ -854,24 +854,6 @@ 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
@@ -1367,8 +1349,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;
@@ -1390,8 +1372,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;

1345
libs/main/containers/pivector2d.h
View File

@@ -1,7 +1,7 @@
/*! \file pivector2d.h
* \brief 2D wrapper around PIVector
*
* This file declares PIVector2D
* This file declares PIVector
*/
/*
PIP - Platform Independent Primitives
@@ -25,85 +25,31 @@
#ifndef PIVECTOR2D_H
#define PIVECTOR2D_H
#include "pipair.h"
#include "pivector.h"
//! \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() для этого), но можно изменять значения существующих элементов.
/*! \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> >
*/
template<typename T>
class PIVector2D {
public:
//! \~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_) {
@@ -117,81 +63,22 @@ 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
//! \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 {
friend class PIVector2D<T>;
@@ -204,417 +91,65 @@ public:
size_t st_, sz_;
public:
//! \~english Returns the number of columns in this row.
//! \~russian Возвращает количество столбцов в этой строке.
//! \return Row size (number of columns).
//! \sa PIVector::size()
inline size_t size() const { return sz_; }
//! \~english Accesses the element at the given column index within the row.
//! \~russian Доступ к элементу по заданному индексу столбца в строке.
//! \details
//! \~english No bounds checking is performed in release builds; use with caution.
//! \~russian В релизной сборке проверка границ не выполняется; используйте с осторожностью.
//! \sa PIVector::operator[]
inline T & operator[](size_t index) { return (*p_)[st_ + index]; }
//! \~english Const access to the element at the given column index within the row.
//! \~russian Константный доступ к элементу по заданному индексу столбца в строке.
//! \sa operator[] (non-const)
inline const T & operator[](size_t index) const { return (*p_)[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(st_ + index); }
//! \~english Returns a const pointer to the row data starting at an optional offset.
//! \~russian Возвращает константный указатель на данные строки, начиная с опционального смещения.
//! \sa data() (non-const)
inline const T * data(size_t index = 0) const { return p_->data(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_ && 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;
}
//! \~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>(sz_, other.size());
p_->_copyRaw(p_->data(st_), other.data(), sz);
return *this;
}
//! \~english Converts the row to a \a PIVector.
//! \~russian Преобразует строку в \a PIVector.
//! \sa PIVector::PIVector(const T*, size_t)
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`.
//! \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 (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 < sz_; ++i) {
func((*p_)[st_ + i]);
}
}
//! \~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 Fills the row with copies of `value`.
//! \~russian Заполняет строку копиями `value`.
//! \sa PIVector::fill()
inline void fill(const T & value) {
for (size_t i = 0; i < sz_; ++i) {
(*p_)[st_ + i] = value;
}
}
//! \~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 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 {
friend class PIVector2D<T>;
private:
inline Col(PIVector2D<T> * p, size_t col): p_(&(p->mat)) {
inline Col(PIVector2D<T> * p, size_t row): p_(&(p->mat)) {
step_ = p->cols_;
col_ = col;
row_ = row;
sz_ = p->rows_;
}
PIVector<T> * p_;
size_t step_, col_, sz_;
size_t step_, row_, sz_;
public:
//! \~english Returns the size of the column (number of rows).
//! \~russian Возвращает размер столбца (количество строк).
inline size_t size() const { return sz_; }
//! \~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 * step_ + col_]; }
//! \~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 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 * 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 Assigns the contents of another Col to this column.
//! \~russian Присваивает этому столбцу содержимое другого столбца.
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_ && col_ == other.col_) return *this;
if (p_ == other.p_ && row_ == other.row_) return *this;
const size_t sz = piMin<size_t>(sz_, other.sz_);
for (size_t i = 0; i < sz; ++i)
(*p_)[i * step_ + col_] = other[i];
for (int i = 0; i < sz; ++i)
(*p_)[i * step_ + row_] = 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) {
inline Row & operator=(const PIVector<T> & other) {
const size_t sz = piMin<size_t>(sz_, other.size());
for (size_t i = 0; i < sz; ++i)
(*p_)[i * step_ + col_] = other[i];
for (int i = 0; i < sz; ++i)
(*p_)[i * step_ + row_] = other[i];
return *this;
}
//! \~english Converts the column to a \a PIVector.
//! \~russian Преобразует столбец в \a PIVector.
inline PIVector<T> toVector() const {
PIVector<T> ret;
ret.reserve(sz_);
for (size_t i = 0; i < sz_; i++)
ret << (*p_)[i * step_ + col_];
ret << (*p_)[i * step_ + row_];
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 (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 < sz_; ++i) {
func((*p_)[i * step_ + col_]);
}
}
//! \~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 Fills the column with copies of `value`.
//! \~russian Заполняет столбец копиями `value`.
//! \sa PIVector::fill()
inline void fill(const T & value) {
for (size_t i = 0; i < sz_; ++i) {
(*p_)[i * step_ + col_] = value;
}
}
//! \~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 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>;
@@ -627,374 +162,73 @@ public:
size_t st_, sz_;
public:
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 col): p_(&(p->mat)) {
inline ColConst(const PIVector2D<T> * p, size_t row): p_(&(p->mat)) {
step_ = p->cols_;
col_ = col;
row_ = row;
sz_ = p->rows_;
}
const PIVector<T> * p_;
size_t step_, col_, sz_;
size_t step_, row_, sz_;
public:
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 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_); }
inline PIVector<T> toVector() const {
PIVector<T> ret;
ret.reserve(sz_);
for (size_t i = 0; i < size(); i++)
ret << (*p_)[i * step_ + col_];
for (int i = 0; i < size(); i++)
ret << (*p_)[i * step_ + row_];
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;
}
};
//! \~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 (bounds-checked only in debug).
//! \~russian Возвращает константную ссылку на элемент по заданной строке и столбцу (проверка границ только в отладочном режиме).
inline const T & at(size_t row, size_t col) const { return mat[row * cols_ + 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); }
//! \~english Replaces a row with the contents of a read-only RowConst object.
//! \~russian Заменяет строку содержимым объекта RowConst только для чтения.
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;
}
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;
}
//! \~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 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;
}
inline PIVector2D<T> & addRow(const RowConst & other) {
if (cols_ == 0) cols_ = other.sz_;
const size_t sz = piMin<size_t>(cols_, other.sz_);
@@ -1004,9 +238,6 @@ public:
rows_++;
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());
@@ -1017,120 +248,34 @@ public:
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 (size() == 0) {
_resizeRaw(other.size(), 1);
for (size_t r = 0; r < other.size(); ++r) {
element(r, 0) = other[r];
}
return *this;
}
const size_t oldCols = cols_;
const size_t newCols = oldCols + 1;
const size_t newSize = rows_ * newCols;
mat._resizeRaw(newSize);
for (size_t r = rows_ - 1; r > 0; --r) {
T * src = mat.data(r * oldCols);
T * dst = mat.data(r * newCols);
memmove(dst, src, oldCols * sizeof(T));
if (r < other.size()) {
mat._copyRaw(&(dst[oldCols]), &(other[r]), 1);
} else {
const T tmp = T();
mat._copyRaw(&(dst[oldCols]), &tmp, 1);
}
}
mat._copyRaw(mat.data(oldCols), &(other[0]), 1);
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 (size() == 0) {
_resizeRaw(other.size(), 1);
for (size_t r = 0; r < other.size(); ++r) {
element(r, 0) = other[r];
}
return *this;
}
const size_t oldCols = cols_;
const size_t newCols = oldCols + 1;
const size_t newSize = rows_ * newCols;
mat._resizeRaw(newSize);
for (size_t r = rows_ - 1; r > 0; --r) {
T * src = mat.data(r * oldCols);
T * dst = mat.data(r * newCols);
memmove(dst, src, oldCols * sizeof(T));
if (r < other.size()) {
mat._copyRaw(&(dst[oldCols]), &(other[r]), 1);
} else {
const T tmp = T();
mat._copyRaw(&(dst[oldCols]), &tmp, 1);
}
}
mat._copyRaw(mat.data(oldCols), &(other[0]), 1);
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()) {
if (rows == rows_ && cols == cols_) return *this;
PIVector2D<T> tmp(rows, cols, f);
size_t copyRows = piMin(rows_, rows);
size_t copyCols = piMin(cols_, cols);
for (size_t r = 0; r < copyRows; ++r) {
for (size_t c = 0; c < copyCols; ++c) {
tmp.element(r, c) = element(r, c);
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);
}
}
swap(tmp);
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());
}
}
}
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_);
@@ -1139,31 +284,18 @@ 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; }
//! \~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 PIVector<T> & plainVector() { return mat; }
inline const PIVector<T> & plainVector() const { return mat; }
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;
@@ -1172,369 +304,29 @@ 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();
}
//! \~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 PIPair<ssize_t, ssize_t> indexOf(const T & e) const {
ssize_t flat = mat.indexOf(e);
if (flat < 0 || cols_ == 0) return PIPair<ssize_t, ssize_t>(-1, -1);
return PIPair<ssize_t, ssize_t>(flat / cols_, flat % cols_);
}
//! \~english Returns the first index (row, col) in the 2D array that passes the `test`.
//! \~russian Возвращает первый индекс (строка, столбец) в двумерном массиве, проходящий `test`.
//! \sa PIVector::indexWhere()
inline PIPair<ssize_t, ssize_t> 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 PIPair<ssize_t, ssize_t>(-1, -1);
return PIPair<ssize_t, ssize_t>(flat / cols_, flat % cols_);
}
//! \~english Returns the last index (row, col) of `e` in the 2D array.
//! \~russian Возвращает последний индекс (строка, столбец) элемента `e` в двумерном массиве.
//! \sa PIVector::lastIndexOf()
inline PIPair<ssize_t, ssize_t> lastIndexOf(const T & e, ssize_t start = -1) const {
ssize_t flat = mat.lastIndexOf(e, start);
if (flat < 0 || cols_ == 0) return PIPair<ssize_t, ssize_t>(-1, -1);
return PIPair<ssize_t, ssize_t>(flat / cols_, flat % cols_);
}
//! \~english Returns the last index (row, col) in the 2D array that passes the `test`.
//! \~russian Возвращает последний индекс (строка, столбец) в двумерном массиве, проходящий `test`.
//! \sa PIVector::lastIndexWhere()
inline PIPair<ssize_t, ssize_t> 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 PIPair<ssize_t, ssize_t>(-1, -1);
return PIPair<ssize_t, ssize_t>(flat / cols_, flat % 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>();
size_t actualRowCount = piMin<size_t>(rowCount, rows_ - rowStart);
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));
return PIVector2D<ST>(rows_, cols_, mat.map(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));
}
inline void forEach(std::function<void(const T &)> f) const { mat.forEach(f); }
//! \~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));
inline PIVector2D<T> & forEach(std::function<void(T &)> f) {
mat.forEach(f);
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 The elements of the specified row are destroyed, and all subsequent rows are shifted up.
//! 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) {
if (row >= rows_) return *this;
mat.remove(row * cols_, cols_);
rows_--;
if (rows_ == 0) cols_ = 0;
return *this;
}
//! \~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) {
if (col >= cols_ || rows_ == 0) return *this;
PIVector2D<T> result(rows_, cols_ - 1);
for (size_t r = 0; r < rows_; ++r) {
for (size_t c = 0, nc = 0; c < cols_; ++c) {
if (c == col) continue;
result.element(r, nc++) = element(r, c);
}
}
swap(result);
return *this;
}
//! \~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(rows_, goodCols.size());
for (size_t r = 0; r < rows_; ++r) {
for (size_t gc = 0; gc < goodCols.size(); ++gc) {
result.element(r, gc) = element(r, 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);
@@ -1554,6 +346,5 @@ inline PICout operator<<(PICout s, const PIVector2D<T> & v) {
return s;
}
//! \}
#endif // PIVECTOR2D_H

1
libs/main/core/piobject.cpp
View File

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

61
libs/main/core/piwaitevent_p.cpp
View File

@@ -18,18 +18,19 @@
*/
#include "piwaitevent_p.h"
#ifdef WINDOWS
#ifndef MICRO_PIP
# 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() {
@@ -39,12 +40,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) {
@@ -53,34 +54,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;
@@ -97,18 +98,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]));
@@ -120,34 +121,36 @@ 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

11
libs/main/core/piwaitevent_p.h
View File

@@ -20,7 +20,9 @@
#ifndef PIWAITEVENT_P_H
#define PIWAITEVENT_P_H
#include "pibase.h"
#ifndef MICRO_PIP
# include "pibase.h"
// clang-format off
#ifdef WINDOWS
# include <stdarg.h>
@@ -52,17 +54,18 @@ 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

20
libs/main/introspection/piintrospection_server_p.cpp
View File

@@ -19,10 +19,12 @@
#include "piintrospection_server_p.h"
#include "pichunkstream.h"
#include "piinit.h"
#include "piobject.h"
#include "pisysteminfo.h"
#if defined(PIP_INTROSPECTION) && !defined(PIP_FORCE_NO_PIINTROSPECTION)
# include "pichunkstream.h"
# include "piinit.h"
# include "piobject.h"
# include "pisysteminfo.h"
const uint PIIntrospection::sign = 0x0F1C2B3A;
@@ -111,9 +113,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();
}
@@ -131,9 +133,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);
@@ -170,3 +172,5 @@ void PIIntrospection::unpackObjects(PIByteArray & ba, PIVector<PIIntrospection::
objects.clear();
ba >> objects;
}
#endif // #if defined(PIP_INTROSPECTION) && !defined(PIP_FORCE_NO_PIINTROSPECTION)

2
libs/main/introspection/piintrospection_server_p.h
View File

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

3
libs/main/introspection/piintrospection_threads_p.cpp
View File

@@ -19,6 +19,7 @@
#include "piintrospection_threads_p.h"
#if defined(PIP_INTROSPECTION) && !defined(PIP_FORCE_NO_PIINTROSPECTION)
PIIntrospectionThreads::ThreadInfo::ThreadInfo() {
id = delay = 0;
@@ -78,3 +79,5 @@ 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)

5
libs/main/introspection/piintrospection_threads_p.h
View File

@@ -20,6 +20,10 @@
#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"
@@ -68,4 +72,5 @@ BINARY_STREAM_READ(PIIntrospectionThreads::ThreadInfo) {
return s;
}
#endif // #if defined(PIP_INTROSPECTION) && !defined(PIP_FORCE_NO_PIINTROSPECTION)
#endif // PIINTROSPECTION_THREADS_P_H

12
libs/main/io_devices/pican.cpp
View File

@@ -20,7 +20,7 @@
#include "pipropertystorage.h"
#include "piwaitevent_p.h"
#if !defined(WINDOWS) && !defined(MAC_OS) && !defined(MICRO_PIP)
#if !defined(WINDOWS) && !defined(MAC_OS) && !defined(PIP_NO_SOCKET)
# define PIP_CAN
#endif
#ifdef PIP_CAN
@@ -39,25 +39,29 @@
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
}
@@ -164,7 +168,9 @@ int PICAN::readedCANID() const {
void PICAN::interrupt() {
#ifdef PIP_CAN
PRIVATE->event.interrupt();
#endif
}

361
libs/main/io_devices/piethernet.cpp
View File

@@ -18,64 +18,65 @@
*/
#include "piethernet.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>
# 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 <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"
#ifndef PIP_NO_SOCKET
#include <errno.h>
# 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 <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
# endif
# include "piwaitevent_p.h"
# include <errno.h>
/** \class PIEthernet piethernet.h
@@ -100,11 +101,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)
@@ -196,11 +197,11 @@ void PIEthernet::construct() {
setMulticastTTL(1);
server_thread_.setData(this);
server_thread_.setName("_S.tcpserver"_a);
#ifdef MICRO_PIP
# ifdef LWIP
setThreadedReadBufferSize(512);
#else
# else
setThreadedReadBufferSize(64_KiB);
#endif
# endif
// setPriority(piHigh);
}
@@ -304,9 +305,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)) {
@@ -379,14 +380,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));
}
@@ -411,30 +412,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());
@@ -457,24 +458,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();
@@ -498,9 +499,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;
@@ -535,9 +536,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)) {
@@ -661,9 +662,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_;
@@ -678,7 +679,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) {
@@ -694,34 +695,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;
}
@@ -745,7 +746,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:
@@ -758,9 +759,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));
@@ -793,11 +794,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_));
@@ -809,9 +810,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();
@@ -847,11 +848,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;
@@ -910,30 +911,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;
}
@@ -969,7 +970,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:
@@ -977,7 +978,7 @@ bool PIEthernet::connectTCP() {
return ethIsWriteable(sock);
default: break;
}
#else
# else
if (PRIVATE->event.wait(sock, PIWaitEvent::CheckWrite)) {
if (ethIsWriteable(sock))
return true;
@@ -986,12 +987,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) {
@@ -1008,7 +1009,7 @@ long PIEthernet::waitForEvent(PIWaitEvent & event, long mask) {
}
return 0;
}
#endif
# endif
bool PIEthernet::configureDevice(const void * e_main, const void * e_parent) {
@@ -1118,7 +1119,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));
@@ -1169,10 +1170,10 @@ PIEthernet::InterfaceList PIEthernet::interfaces() {
}
}
if (pAdapterInfo) HeapFree(GetProcessHeap(), 0, pAdapterInfo);
#else
# ifdef MICRO_PIP
# else
# ifdef ANDROID
# ifdef LWIP
# else
# ifdef ANDROID
struct ifconf ifc;
int s = ::socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
ifc.ifc_len = 256;
@@ -1200,7 +1201,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) {
@@ -1218,8 +1219,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;
@@ -1227,9 +1228,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) {
@@ -1240,7 +1241,7 @@ PIEthernet::InterfaceList PIEthernet::interfaces() {
}
pclose(fp);
}
# else
# else
if (s != -1) {
struct ifreq ir;
memset(&ir, 0, sizeof(ir));
@@ -1252,8 +1253,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;
@@ -1274,18 +1275,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(MICRO_PIP)
# if defined(WINDOWS) || defined(LWIP)
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());
@@ -1294,7 +1295,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
}
@@ -1317,16 +1318,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,
@@ -1343,18 +1344,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);
@@ -1363,29 +1364,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,
@@ -1399,26 +1400,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;
}
@@ -1426,11 +1427,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));
}
@@ -1438,11 +1439,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));
}
@@ -1450,12 +1451,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
}
@@ -1471,7 +1472,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);
@@ -1479,10 +1480,12 @@ 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

18
libs/main/io_devices/piethernet.h
View File

@@ -26,14 +26,17 @@
#ifndef PIETHERNET_H
#define PIETHERNET_H
#include "piiodevice.h"
#include "pinetworkaddress.h"
#ifdef ANDROID
#ifndef PIP_NO_SOCKET
# ifdef ANDROID
struct
#else
# else
class
#endif
# endif
sockaddr;
class PIP_EXPORT PIEthernet: public PIIODevice {
@@ -439,7 +442,7 @@ public:
//! \}
//! \ioparams
//! \{
#ifdef DOXYGEN
# ifdef DOXYGEN
//! \brief read ip, default ""
string ip;
@@ -460,7 +463,7 @@ public:
//! \brief time-to-live for multicast, default 1
int multicastTTL;
#endif
# endif
//! \}
protected:
@@ -509,9 +512,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();
@@ -536,4 +539,5 @@ 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

2
libs/main/io_devices/pifile.cpp
View File

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

375
libs/main/io_devices/piserial.cpp
View File

@@ -19,38 +19,37 @@
#include "piserial.h"
#include "piconfig.h"
#include "pidir.h"
#include "piincludes_p.h"
#include "pipropertystorage.h"
#include "pitime.h"
#include "pitranslator.h"
#include "piwaitevent_p.h"
#ifndef MICRO_PIP
#include <errno.h>
# include "piconfig.h"
# include "pidir.h"
# include "piincludes_p.h"
# include "pipropertystorage.h"
# include "pitime.h"
# include "pitranslator.h"
# include "piwaitevent_p.h"
#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>
# 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
# 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>
@@ -59,89 +58,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
# 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
# endif
# ifndef B75
# define B75 0000002
# ifndef CRTSCTS
# define CRTSCTS 020000000000
# endif
# ifndef B230400
# define B230400 0010003
# ifdef LINUX
# include <linux/serial.h>
# 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
@@ -177,16 +176,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)
@@ -214,9 +213,9 @@ PISerial::~PISerial() {
stopAndWait();
close();
PRIVATE->event.destroy();
#ifdef WINDOWS
# ifdef WINDOWS
PRIVATE->event_write.destroy();
#endif
# endif
}
@@ -347,7 +346,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();
@@ -363,14 +362,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;
}
@@ -380,8 +379,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];
@@ -392,14 +391,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;
}
@@ -410,23 +409,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
}
@@ -441,9 +440,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;
@@ -463,13 +462,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
}
@@ -672,9 +671,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
}
@@ -696,7 +695,7 @@ bool PISerial::openDevice() {
}
}
if (p.isEmpty()) return false;
#ifdef WINDOWS
# ifdef WINDOWS
DWORD ds = 0, sm = 0;
if (isReadable()) {
ds |= GENERIC_READ;
@@ -714,7 +713,7 @@ bool PISerial::openDevice() {
return false;
}
fd = 0;
#else
# else
int om = 0;
switch (mode()) {
case PIIODevice::ReadOnly: om = O_RDONLY; break;
@@ -729,12 +728,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;
}
@@ -745,28 +744,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);
@@ -792,7 +791,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;
@@ -826,12 +825,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;
@@ -845,9 +844,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
}
@@ -866,7 +865,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;
@@ -896,7 +895,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;
@@ -911,7 +910,7 @@ ssize_t PISerial::readDevice(void * read_to, ssize_t max_size) {
}
}
return ret;
#endif
# endif
}
@@ -920,7 +919,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;
@@ -932,11 +931,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";
}
@@ -1061,9 +1060,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;
@@ -1079,7 +1078,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);
@@ -1147,13 +1146,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) {
@@ -1182,12 +1181,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"
@@ -1198,14 +1197,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;
@@ -1226,18 +1225,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) + "/";
@@ -1253,16 +1252,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,
@@ -1271,31 +1270,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;
@@ -1309,12 +1308,14 @@ 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

10
libs/main/piplatform.h
View File

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

4
libs/main/serialization/pijson.cpp
View File

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

39
libs/main/serialization/pivaluetree_conversions.cpp
View File

@@ -42,14 +42,6 @@ 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;
@@ -300,11 +292,7 @@ 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()) {
if (c.hasChildren()) continue;
ret += toTextTree(c, prefix, options);
}
for (const auto & c: root.children()) {
if (!c.hasChildren()) continue;
PIString cp = prefix;
ret += toTextTree(c, prefix, options);
}
} else {
@@ -327,13 +315,9 @@ PIString toTextTree(const PIValueTree & root, PIString prefix, PIValueTreeConver
PIString PIValueTreeConversions::toText(const PIValueTree & root, Options options) {
PIString ret;
for (const auto & c: root.children()) {
if (c.hasChildren()) continue;
ret += toTextTree(c, {}, options);
}
for (const auto & c: root.children()) {
if (!c.hasChildren()) continue;
ret += toTextTree(c, {}, options);
ret += toTextTree(c, PIString(), options);
}
return ret;
}
@@ -345,26 +329,13 @@ PIValueTree PIValueTreeConversions::fromText(const PIString & str) {
PIValueTree PIValueTreeConversions::fromJSONFile(const PIString & 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;
return PIValueTreeConversions::fromJSON(PIJSON::fromJSON(PIString::fromUTF8(PIFile::readAll(path))));
}
PIValueTree PIValueTreeConversions::fromTextFile(const PIString & path) {
PIFile f(path, PIIODevice::ReadOnly);
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;
return PIValueTreeConversions::fromText(&f);
}

13
libs/main/system/pihidevice.cpp
View File

@@ -122,10 +122,6 @@ bool PIHIDevice::open(const PIHIDeviceInfo & device) {
return false;
}
HidD_GetPreparsedData(PRIVATE->deviceHandle, &PRIVATE->preparsed);
if (!PRIVATE->preparsed) {
close();
return false;
}
return true;
#endif
}
@@ -342,12 +338,12 @@ PIVector<PIHIDeviceInfo> PIHIDevice::allDevices(bool try_open) {
PIDir hid_dir("/sys/bus/hid/devices"_a);
auto hid_devs = hid_dir.entries();
for (const auto & hd: hid_devs) {
for (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 (const auto & hd_i: hid_inputs) {
for (auto hd_i: hid_inputs) {
if (!isDir(hd_i)) continue;
// now in /sys/bus/hid/devices/<dev>/input/input<N>
// piCout << hd_i.path;
@@ -364,7 +360,7 @@ PIVector<PIHIDeviceInfo> PIHIDevice::allDevices(bool try_open) {
PIDir dir_e(hd_i.path);
PIStringList devs;
auto dl_e = dir_e.entries();
for (const auto & d_e: dl_e) {
for (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();
}
@@ -392,7 +388,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;
@@ -528,7 +524,6 @@ 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);

7
libs/main/text/pistring.cpp
View File

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

17
libs/main/types/pivaluetree.cpp
View File

@@ -124,23 +124,6 @@ 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()) {

7
libs/main/types/pivaluetree.h
View File

@@ -170,13 +170,6 @@ 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.

1436
tests/math/testpivector2d.cpp
View File

@@ -1,1433 +1,85 @@
#include "pistring.h"
#include "pivector2d.h"
#include "gtest/gtest.h"
#include <numeric>
size_t ROWS_COUNT_INIT = 31;
size_t COLS_COUNT_INIT = 34;
int ROWS_COUNT_INIT = 31;
int ROWS_COUNT_INCREASE = 41;
int COLS_COUNT_INCREASE = 44;
int ROWS_COUNT_REDUCE = 22;
int COLS_COUNT_INIT = 34;
int COLS_COUNT_INCREASE = 44;
int COLS_COUNT_REDUCE = 13;
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;
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 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 {
class Vector2D: public ::testing::Test {
protected:
PIVector2D<int> vec = PIVector2D<int>(ROWS_COUNT_INIT, COLS_COUNT_INIT);
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
}
}
// ==================== 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, 999);
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), 999);
}
}
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());
piCout << r << vec.cols() << oldVec.cols() << colIndex;
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 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 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_reduce_is_data_stay_consistent(int newRowsCount, int newColsCount) {
vec.resize(newRowsCount, newColsCount, 0);
assert_fill_with(vec, newRowsCount, newColsCount);
}
// 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);
}
}
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 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);
}
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);
}
}
}
};
TEST_F(Vector2DResizeTest, resize_increase_both_preserves_data) {
assert_resize_increase_initializes_new(ROWS_COUNT_INCREASE, COLS_COUNT_INCREASE);
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_rows_only_preserves_data) {
assert_resize_increase_initializes_new(ROWS_COUNT_INCREASE, COLS_COUNT_INIT);
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_cols_only_preserves_data) {
assert_resize_increase_initializes_new(ROWS_COUNT_INIT, COLS_COUNT_INCREASE);
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_reduce_both_preserves_data) {
assert_resize_reduce_preserves_data(ROWS_COUNT_REDUCE, COLS_COUNT_REDUCE);
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_rows_only_preserves_data) {
assert_resize_reduce_preserves_data(ROWS_COUNT_REDUCE, COLS_COUNT_INIT);
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_cols_only_preserves_data) {
assert_resize_reduce_preserves_data(ROWS_COUNT_INIT, COLS_COUNT_REDUCE);
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_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_rows_is_data_stay_consistent) {
resize_reduce_is_data_stay_consistent(ROWS_COUNT_REDUCE, COLS_COUNT_INIT);
}
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.first, 10);
EXPECT_EQ(p.second, 15);
p = vec.indexOf(-999);
EXPECT_EQ(p.first, -1);
EXPECT_EQ(p.second, -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.first, 5);
EXPECT_EQ(p.second, 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.first, 20);
EXPECT_EQ(p.second, 20);
}
TEST_F(Vector2DTest, lastIndexWhere_works) {
auto isLarge = [](const int & e) { return e > 500; };
auto p = vec.lastIndexWhere(isLarge);
EXPECT_GE(p.first, 0);
EXPECT_GE(p.second, 0);
// The last element with value >500 should be the largest index
size_t lastFlat = p.first * vec.cols() + p.second;
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
TEST_F(Vector2D, resize_reduce_both_is_data_stay_consistent) {
resize_reduce_is_data_stay_consistent(ROWS_COUNT_REDUCE, COLS_COUNT_REDUCE);
}
#endif

2
utils/value_tree_translator/main.cpp
View File

@@ -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, Attribute::toolTip});
const static PIStringList attrs({Attribute::prefix, Attribute::suffix});
for (const auto & c: vt.children()) {
context.confirm(c.name(), loc);
context.confirm(c.comment(), loc);