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

merged AI doc, some new pages

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

84
libs/main/core/pibase.h
View File

@@ -1,17 +1,17 @@
/*! \file pibase.h
* \ingroup Core
* \~\brief
* \~english Base types and functions
* \~russian Базовые типы и методы
*
* \~\details
* \~english
* This file implements first layer above the system and
* declares some basic useful functions
* \~russian
* Этот файл реализует первый слой после системы и объявляет
* несколько базовых полезных методов
*/
//! \addtogroup Core
//! \{
//! \~\file pibase.h
//! \brief
//! \~english Base types and functions
//! \~russian Базовые типы и методы
//! \details
//! \~english
//! This file implements first layer above the system and
//! declares some basic useful functions
//! \~russian
//! Этот файл реализует первый слой после системы и объявляет
//! несколько базовых полезных методов
//! \~\}
/*
PIP - Platform Independent Primitives
Base types and functions
@@ -245,6 +245,9 @@ inline constexpr T piAbs(const T & v) {
}
//! \~\brief
//! \~english Templated function return minimum of two values
//! \~russian Шаблонный метод, возвращающий минимум из двух значений
template<typename T>
constexpr T piMin(const T & f, const T & s) {
return ((f > s) ? s : f);
@@ -282,6 +285,9 @@ constexpr T piMin(const T & f, const T & s, const Args &... args) {
}
//! \~\brief
//! \~english Templated function return maximum of two values
//! \~russian Шаблонный метод, возвращающий максимум из двух значений
template<typename T>
constexpr T piMax(const T & f, const T & s) {
return ((f < s) ? s : f);
@@ -509,51 +515,87 @@ inline uint piHashData(const uchar * data, uint len, uint seed = 0) {
}
//! \~\brief
//! \~english Generic hash function, returns 0 for unknown types
//! \~russian Хэш-функция общего назначения, возвращает 0 для неизвестных типов
template<typename T>
inline uint piHash(const T & v) {
return 0;
}
//! \~\brief
//! \~english Hash function specialization for char type
//! \~russian Специализация хэш-функции для типа char
template<>
inline uint piHash(const char & v) {
return (uint)v;
}
//! \~\brief
//! \~english Hash function specialization for uchar type
//! \~russian Специализация хэш-функции для типа uchar
template<>
inline uint piHash(const uchar & v) {
return (uint)v;
}
//! \~\brief
//! \~english Hash function specialization for short type
//! \~russian Специализация хэш-функции для типа short
template<>
inline uint piHash(const short & v) {
return (uint)v;
}
//! \~\brief
//! \~english Hash function specialization for ushort type
//! \~russian Специализация хэш-функции для типа ushort
template<>
inline uint piHash(const ushort & v) {
return (uint)v;
}
//! \~\brief
//! \~english Hash function specialization for int type
//! \~russian Специализация хэш-функции для типа int
template<>
inline uint piHash(const int & v) {
return (uint)v;
}
//! \~\brief
//! \~english Hash function specialization for uint type
//! \~russian Специализация хэш-функции для типа uint
template<>
inline uint piHash(const uint & v) {
return (uint)v;
}
//! \~\brief
//! \~english Hash function specialization for llong type using piHashData
//! \~russian Специализация хэш-функции для типа llong с использованием piHashData
template<>
inline uint piHash(const llong & v) {
return piHashData((const uchar *)&v, sizeof(v));
}
//! \~\brief
//! \~english Hash function specialization for ullong type using piHashData
//! \~russian Специализация хэш-функции для типа ullong с использованием piHashData
template<>
inline uint piHash(const ullong & v) {
return piHashData((const uchar *)&v, sizeof(v));
}
//! \~\brief
//! \~english Hash function specialization for float type
//! \~russian Специализация хэш-функции для типа float
template<>
inline uint piHash(const float & v) {
return (uint)v;
}
//! \~\brief
//! \~english Hash function specialization for double type using piHashData
//! \~russian Специализация хэш-функции для типа double с использованием piHashData
template<>
inline uint piHash(const double & v) {
return piHashData((const uchar *)&v, sizeof(v));
}
//! \~\brief
//! \~english Hash function specialization for ldouble type using piHashData
//! \~russian Специализация хэш-функции для типа ldouble с использованием piHashData
template<>
inline uint piHash(const ldouble & v) {
return piHashData((const uchar *)&v, sizeof(v));
@@ -736,16 +778,30 @@ struct PIP_EXPORT PINonTriviallyCopyable {
inline PINonTriviallyCopyable::PINonTriviallyCopyable(PINonTriviallyCopyable &&) noexcept = default;
//! \~\brief
//! \~english Template struct for extracting function type from callable objects
//! \~russian Шаблонная структура для извлечения типа функции из вызываемых объектов
template<typename T>
struct FunctionType {
using Type = void;
};
//! \~\brief
//! \~english Specialization for member function pointers
//! \~russian Специализация для указателей на члены класса
template<typename Ret, typename Class, typename... Args>
struct FunctionType<Ret (Class::*)(Args...) const> {
using Type = std::function<Ret(Args...)>;
};
//! \~\brief
//! \~english Convert lambda/functional object to std::function
//! \~russian Преобразует лямбду/функциональный объект в std::function
//! \~\details
//! \~english
//! Uses FunctionType template to extract the function signature from the callable object
//! \~russian
//! Использует шаблон FunctionType для извлечения сигнатуры функции из вызываемого объекта
template<typename L>
typename FunctionType<decltype(&L::operator())>::Type toStdFunction(L const & func) {
return func;

110
libs/main/core/pibase_macros.h
View File

@@ -1,15 +1,17 @@
/*! \file pibase_macros.h
* \ingroup Core
* \~\brief
* \~english Base macros
* \~russian Базовые макросы
*
* \~\details
* \~english
* This file declares basic useful maros
* \~russian
* Этот файл объявляет основные вспомогательные макросы
*/
//! \addtogroup Core
//! \{
//! \~\file pibase_macros.h
//! \brief
//! \~english Base macros
//! \~russian Базовые макросы
//! \details
//! \~english
//! This file declares basic useful macros for the PIP library including platform detection,
//! compiler-specific configurations, and utility macros for private data handling.
//! \~russian
//! Этот файл объявляет основные вспомогательные макросы для библиотеки PIP, включая обнаружение платформы,
//! конфигурации, специфичные для компилятора, и служебные макросы для работы с приватными данными.
//! \~\}
/*
PIP - Platform Independent Primitives
Base macros
@@ -46,151 +48,123 @@
//! Содержит набор пар ключ=значение, например
//! \~
//! PIMETA(id=12345,tag="my string")
//! \~\sa PIMETA
#define PIMETA(...)
#ifdef DOXYGEN
//! \~\brief
//! \~english Major value of PIP version
//! \~russian Мажорная версия PIP
# define PIP_VERSION_MAJOR
//! \~\brief
//! \~english Minor value of PIP version
//! \~russian Минорная версия PIP
# define PIP_VERSION_MINOR
//! \~\brief
//! \~english Revision value of PIP version
//! \~russian Ревизия версии PIP
# define PIP_VERSION_REVISION
//! \~\brief
//! \~english Suffix of PIP version
//! \~russian Суффикс версии PIP
# define PIP_VERSION_SUFFIX
//! \~\brief
//! \~english Version of PIP in hex - 0x##(Major)##(Minor)##(Revision)
//! \~russian Версия PIP в hex - 0x##(Major)##(Minor)##(Revision)
# define PIP_VERSION
//! \~\brief
//! \~english Macro is defined when compile-time debug is enabled
//! \~russian Макрос объявлен когда включена compile-time отладка
# define PIP_DEBUG
//! \~\brief
//! \~english Macro is defined when operation system is any Windows
//! \~russian Макрос объявлен когда операционная система Windows
# define WINDOWS
//! \~\brief
//! \~english Macro is defined when operation system is QNX or Blackberry
//! \~russian Макрос объявлен когда операционная система QNX или Blackberry
# define QNX
//! \~\brief
//! \~english Macro is defined when operation system is Blackberry
//! \~russian Макрос объявлен когда операционная система Blackberry
# define BLACKBERRY
//! \~\brief
//! \~english Macro is defined when operation system is FreeBSD
//! \~russian Макрос объявлен когда операционная система FreeBSD
# define FREE_BSD
//! \~\brief
//! \~english Macro is defined when operation system is Mac OS
//! \~russian Макрос объявлен когда операционная система Mac OS
# define MAC_OS
//! \~\brief
//! \~english Macro is defined when operation system is Android
//! \~russian Макрос объявлен когда операционная система Android
# define ANDROID
//! \~\brief
//! \~english Macro is defined when operation system is any Linux
//! \~russian Макрос объявлен когда операционная система Linux
# define LINUX
//! \~\brief
//! \~english Macro is defined when operation system is FreeRTOS
//! \~russian Макрос объявлен когда операционная система FreeRTOS
# define FREERTOS
//! \~\brief
//! \~english Macro is defined when compiler is GCC or MinGW
//! \~russian Макрос объявлен когда компилятор GCC или MinGW
# define CC_GCC
//! \~\brief
//! \~english Macro is defined when PIP is decided that host is support language
//! \~russian Макрос объявлен когда PIP решил что система поддерживает локализацию
# define HAS_LOCALE
//! \~\brief
//! \~english Macro is defined when PIP is building for embedded systems
//! \~russian Макрос объявлен когда PIP собирается для встраиваемых систем
# define MICRO_PIP
//! \~\brief
//! \~english Macro is defined when compiler is Visual Studio
//! \~russian Макрос объявлен когда компилятор Visual Studio
# define CC_VC
//! \~\brief
//! \~english Macro is defined when compiler is AVR GCC
//! \~russian Макрос объявлен когда компилятор AVR GCC
# define CC_AVR_GCC
//! \~\brief
//! \~english Macro is defined when compiler is unknown
//! \~russian Макрос объявлен когда компилятор неизвестен
# define CC_OTHER
//! \~\brief
//! \~english Macro to declare private section, "export" is optional
//! \~russian Макрос для объявления частной секции, "export" необязателен
# define PRIVATE_DECLARATION(export)
//! \~\brief
//! \~english Macro to start definition of private section
//! \~russian Макрос для начала реализации частной секции
# define PRIVATE_DEFINITION_START(Class)
//! \~\brief
//! \~english Macro to end definition of private section
//! \~russian Макрос для окончания реализации частной секции
# define PRIVATE_DEFINITION_END(Class)
//! \~\brief
//! \~english Macro to access private section by pointer
//! \~russian Макрос для доступа к частной секции
# define PRIVATE
//! \~\brief
//! \~english Macro to access private section by pointer without brakes ()
//! \~english Macro to access private section by pointer without braces ()
//! \~russian Макрос для доступа к частной секции без обрамляющих скобок ()
# define PRIVATEWB
//! \~\brief
//! \~english Macro to start static initializer
//! \~russian Макрос для начала статической инициализации
# define STATIC_INITIALIZER_BEGIN
//! \~\brief
//! \~english Macro to end static initializer
//! \~russian Макрос для окончания статической инициализации
# define STATIC_INITIALIZER_END
//! \~\brief
//! \~english Macro to remove class copy availability
//! \~russian Макрос для запрета копирования класса
# define NO_COPY_CLASS(Class)
//! \~\brief
//! \~english Macro to supress compiler warning about unused variable
//! \~russian Макрос для подавления предупреждения компилятора о неиспользуемой переменной
# define NO_UNUSED(x)
@@ -320,6 +294,9 @@ typedef long long ssize_t;
// Private data macros
#ifndef DOXYGEN
//! \~english Macro to declare private section, "export" is optional
//! \~russian Макрос для объявления частной секции, "export" необязателен
//! \~sa PRIVATE PRIVATEWB
# define PRIVATE_DECLARATION(e) \
struct __Private__; \
friend struct __Private__; \
@@ -332,10 +309,20 @@ typedef long long ssize_t;
}; \
__PrivateInitializer__ __privateinitializer__;
//! \~english Macro to start definition of private section
//! \~russian Макрос для начала реализации частной секции
//! \~sa PRIVATE_DEFINITION_END PRIVATE_DEFINITION_END_NO_INITIALIZE PRIVATE_DEFINITION_INITIALIZE PRIVATE PRIVATEWB
# define PRIVATE_DEFINITION_START(c) struct c::__Private__ {
//! \~english Macro to end definition of private section without initialization
//! \~russian Макрос для окончания реализации частной секции без инициализации
//! \~sa PRIVATE_DEFINITION_END PRIVATE_DEFINITION_START PRIVATE_DEFINITION_INITIALIZE PRIVATE PRIVATEWB
# define PRIVATE_DEFINITION_END_NO_INITIALIZE(c) \
} \
;
//! \~english Macro to initialize private section
//! \~russian Макрос для инициализации частной секции
//! \~sa PRIVATE_DEFINITION_END PRIVATE_DEFINITION_START PRIVATE_DEFINITION_END_NO_INITIALIZE PRIVATE PRIVATEWB
# define PRIVATE_DEFINITION_INITIALIZE(c) \
c::__PrivateInitializer__::__PrivateInitializer__() { \
p = new c::__Private__(); \
@@ -351,31 +338,51 @@ typedef long long ssize_t;
p = new c::__Private__(); \
return *this; \
}
//! \~english Macro to end definition of private section with initialization
//! \~russian Макрос для окончания реализации частной секции с инициализацией
//! \~sa PRIVATE_DEFINITION_END_NO_INITIALIZE PRIVATE_DEFINITION_START PRIVATE_DEFINITION_INITIALIZE PRIVATE PRIVATEWB
# define PRIVATE_DEFINITION_END(c) \
PRIVATE_DEFINITION_END_NO_INITIALIZE \
(c) PRIVATE_DEFINITION_INITIALIZE(c)
//! \~english Macro to access private section by pointer
//! \~russian Макрос для доступа к частной секции
//! \~sa PRIVATEWB
# define PRIVATE (__privateinitializer__.p)
//! \~english Macro to access private section by pointer without braces ()
//! \~russian Макрос для доступа к частной секции без обрамляющих скобок ()
//! \~sa PRIVATE
# define PRIVATEWB __privateinitializer__.p
#endif // DOXYGEN
//! \~english Macro to remove class copy availability
//! \~russian Макрос для запрета копирования класса
#define NO_COPY_CLASS(name) \
name(const name &) = delete; \
name & operator=(const name &) = delete;
//! \~english Counter macro for unique identifier generation
//! \~russian Макрос счетчика для генерации уникальных идентификаторов
#define _PIP_ADD_COUNTER_WS(a, cnt, line) a##cnt##_##line
#define _PIP_ADD_COUNTER_WF(a, cnt, line) _PIP_ADD_COUNTER_WS(a, cnt, line)
#define _PIP_ADD_COUNTER(a) _PIP_ADD_COUNTER_WF(a, __COUNTER__, __LINE__)
//! \~english Macro to start static initializer
//! \~russian Макрос для начала статической инициализации
//! \~sa STATIC_INITIALIZER_END
#define STATIC_INITIALIZER_BEGIN \
class { \
class _Initializer_ { \
public: \
_Initializer_() {
//! \~english Macro to end static initializer
//! \~russian Макрос для окончания статической инициализации
//! \~sa STATIC_INITIALIZER_BEGIN
#define STATIC_INITIALIZER_END \
} \
} \
@@ -384,12 +391,12 @@ typedef long long ssize_t;
_PIP_ADD_COUNTER(_pip_initializer_);
//! \~\brief
//! \~english Minimal sleep in milliseconds for internal PIP using
//! \~russian Минимальное значание задержки в милисекундах для внутреннего использования в библиотеке PIP
//! \~\details
//! \~english Using in \a piMinSleep(), \a PIThread, \a PITimer::Pool. By default 1ms.
//! \~russian Используется в \a piMinSleep(), \a PIThread, \a PITimer::Pool. По умолчанию равна 1мс.
//! \~\sa PIP_MIN_MSLEEP
#ifndef PIP_MIN_MSLEEP
# ifndef MICRO_PIP
# define PIP_MIN_MSLEEP 1.
@@ -399,19 +406,26 @@ typedef long long ssize_t;
#endif
//! \~\brief
//! \~english Macro used for infinite loop
//! \~russian Макрос для бесконечного цикла
//! \~\details
//! \~english Expands to \c for(;;) infinite loop construct
//! \~russian Раскрывается в конструкцию бесконечного цикла \c for(;;)
#define FOREVER for (;;)
//! \~\brief
//! \~english Macro used for infinite wait
//! \~russian Макрос для бесконечного ожидания
//! \~\details
//! \~english Expands to infinite loop with periodic sleep calls for CPU-friendly waiting
//! \~russian Раскрывается в бесконечный цикл с периодическими вызовами sleep для экономии ресурсов CPU
#define FOREVER_WAIT FOREVER piMinSleep();
//! \~\brief
//! \~english Macro used for infinite wait
//! \~russian Макрос для бесконечного ожидания
//! \~\details
//! \~english Expands to infinite loop with periodic sleep calls for CPU-friendly waiting
//! \~russian Раскрывается в бесконечный цикл с периодическими вызовами sleep для экономии ресурсов CPU
//! \~\sa FOREVER_WAIT
#define WAIT_FOREVER FOREVER piMinSleep();

76
libs/main/core/picollection.h
View File

@@ -1,9 +1,13 @@
/*! \file picollection.h
* \ingroup Core
* \~\brief
* \~english Unique classes collection
* \~russian Коллекция уникальных классов
*/
//! \addtogroup Core
//! \{
//! \~\file picollection.h
//! \brief
//! \~english Unique classes collection
//! \~russian Коллекция уникальных классов
//! \details
//! \~english Helper module to collect and retrieve classes into groups using macros for automatic registration.
//! \~russian Модуль-помощник для сбора и получения классов в группы с помощью макросов для автоматической регистрации.
//! \~\}
/*
PIP - Platform Independent Primitives
Peer - named I/O ethernet node, forming self-organized peering network
@@ -30,10 +34,10 @@
#ifdef DOXYGEN
//! \~\relatesalso PICollection
//! \relatesalso PICollection
//! \~\brief
//! \~english Add existing element "object" in group with name "group"
//! \~russian Добавляет существующий элемент "object" в группу с именем "group"
//! \~english Adds existing object to group "group".
//! \~russian Добавляет существующий объект в группу "group".
//! \~\details
//! \~english
//! If this is no group with name "group" it will be created.
@@ -46,21 +50,21 @@
//! то ничего не изменится. \n "object" должен быть наследником \a PIObject.
# define ADD_TO_COLLECTION(group, object)
//! \~\relatesalso PICollection
//! \relatesalso PICollection
//! \~\brief
//! \~english Add existing element "object" in group with name "group" and set its name to "name"
//! \~russian Добавляет существующий элемент "object" в группу с именем "group" и присваивает объекту имя "name"
//! \~english Adds existing object to group "group" and assigns name "name".
//! \~russian Добавляет существующий объект в группу "group" и присваивает ему имя "name".
//! \~\details
//! \~english
//! Similar to \a ADD_TO_COLLECTION(group, object) but set object name to "name"
//! Similar to \a ADD_TO_COLLECTION(group, object), but also sets object name.
//! \~russian
//! Аналогично \a ADD_TO_COLLECTION(group, object), но присваивает имя объекту "name"
//! Аналогично \a ADD_TO_COLLECTION(group, object), но дополнительно задает имя объекта.
# define ADD_TO_COLLECTION_WITH_NAME(group, object, name)
//! \~\relatesalso PICollection
//! \relatesalso PICollection
//! \~\brief
//! \~english Add new element of class "class" in group with name "group"
//! \~russian Добавляет новый элемент класса "class" в группу с именем "group"
//! \~english Creates and adds new object of class "class" to group "group".
//! \~russian Создает и добавляет новый объект класса "class" в группу "group".
//! \~\details
//! \~english
//! If this is no group with name "group" it will be created.
@@ -73,15 +77,17 @@
//! то ничего не изменится. \n "class" должен быть любым классом, наследным от \a PIObject.
# define ADD_NEW_TO_COLLECTION(group, class)
//! \~\relatesalso PICollection
//! \relatesalso PICollection
//! \~\brief
//! \~english Add new element of class "class" in group with name "group" and set its name to "name"
//! \~russian Добавляет новый элемент класса "class" в группу с именем "group" и присваивает объекту имя "name"
//! \~english Creates and adds new object of class "class" to group "group"
//! and assigns name "name".
//! \~russian Создает и добавляет новый объект класса "class" в группу "group"
//! и присваивает ему имя "name".
//! \~\details
//! \~english
//! Similar to \a ADD_NEW_TO_COLLECTION(group, class) but set object name to "name"
//! Similar to \a ADD_NEW_TO_COLLECTION(group, class), but also sets object name.
//! \~russian
//! Аналогично \a ADD_NEW_TO_COLLECTION(group, class), но присваивает имя объекту "name"
//! Аналогично \a ADD_NEW_TO_COLLECTION(group, class), но дополнительно задает имя объекта.
# define ADD_NEW_TO_COLLECTION_WITH_NAME(group, class, name)
#else
@@ -100,28 +106,40 @@
#endif
//! \ingroup Core
//! \~\ingroup Core
//! \~\brief
//! \~english Helper to collect and retrieve classes to groups.
//! \~russian Помощник для создания и получения классов в группы.
//! \~english Global collection of %PIObject-based instances grouped by name.
//! \~russian Глобальная коллекция экземпляров на базе %PIObject, сгруппированных по имени.
class PIP_EXPORT PICollection {
friend class __PICollectionInitializer;
public:
//! \~english Constructs collection helper.
//! \~russian Создает вспомогательный объект коллекции.
PICollection() { ; }
//! \~english Returns all existing groups by their names
//! \~russian Возвращает имена всех групп
//! \~english Returns names of all existing groups.
//! \~russian Возвращает имена всех существующих групп.
static PIStringList groups();
//! \~english Returns all elements of group "group"
//! \~russian Возвращает все элементы группы "group"
//! \~english Returns all elements stored in group "group".
//! \~russian Возвращает все элементы, хранящиеся в группе "group".
static PIVector<const PIObject *> groupElements(const PIString & group);
//! \~english Adds object to group "group" if that group has no object of the
//! same runtime class.
//! \~russian Добавляет объект в группу "group", если в группе еще нет объекта
//! того же класса времени выполнения.
static bool addToGroup(const PIString & group, const PIObject * element);
//! \~\ingroup Core
//! \~\brief
//! \~english Helper that registers object in collection during static initialization.
//! \~russian Вспомогательный класс, регистрирующий объект в коллекции при статической инициализации.
class PIP_EXPORT CollectionAdder {
public:
//! \~english Registers object in group and optionally assigns object name.
//! \~russian Регистрирует объект в группе и при необходимости задает имя объекта.
CollectionAdder(const PIString & group, const PIObject * element, const PIString & name = PIString(), bool own = false);
};

16
libs/main/core/picoremodule.h
View File

@@ -1,3 +1,13 @@
/*! \file picoremodule.h
* \ingroup Core
* \~\brief
* \~english Umbrella header for the Core module
* \~russian Агрегирующий заголовок модуля Core
*
* \~\details
* \~english Includes the public chunk stream, collection, JSON, object, property storage, and time headers.
* \~russian Подключает публичные заголовки потоков чанков, коллекций, JSON, объектов, хранилища свойств и времени.
*/
/*
PIP - Platform Independent Primitives
Module includes
@@ -34,10 +44,12 @@
//! \~russian \par Общее
//!
//! \~english
//! These files provides platform abstraction, useful macros, methods and classes
//! These headers provide platform abstraction, common macros, utility functions
//! and base classes.
//!
//! \~russian
//! Эти файлы обеспечивают абстракцию операционной системы, полезные макросы, методы и классы
//! Эти заголовки предоставляют абстракцию платформы, общие макросы,
//! вспомогательные функции и базовые классы.
//!
//! \~\authors
//! \~english

128
libs/main/core/picout.h
View File

@@ -1,9 +1,10 @@
/*! \file picout.h
* \ingroup Core
* \~\brief
* \~english Universal output to console class
* \~russian Универсальный вывод в консоль
*/
//! \addtogroup Core
//! \{
//! \~\file picout.h
//! \brief
//! \~english Universal output to console class
//! \~russian Универсальный вывод в консоль
//! \~\}
/*
PIP - Platform Independent Primitives
Universal output to console class
@@ -50,13 +51,13 @@
#else
# define piCout PICout(piDebug, PICoutStdStream::StdOut)
# define piCoutObj \
PICout(piDebug && debug(), PICoutStdStream::StdOut) \
<< (PIStringAscii("[") + className() + (name().isEmpty() ? "]" : PIStringAscii(" \"") + name() + PIStringAscii("\"]")))
# define piCoutObj \
PICout(piDebug && debug(), PICoutStdStream::StdOut) \
<< (PIStringAscii("[") + className() + (name().isEmpty() ? "]" : PIStringAscii(" \"") + name() + PIStringAscii("\"]")))
# define piCerr PICout(piDebug, PICoutStdStream::StdErr)
# define piCerrObj \
PICout(piDebug && debug(), PICoutStdStream::StdErr) \
<< (PIStringAscii("[") + className() + (name().isEmpty() ? "]" : PIStringAscii(" \"") + name() + PIStringAscii("\"]")))
# define piCerrObj \
PICout(piDebug && debug(), PICoutStdStream::StdErr) \
<< (PIStringAscii("[") + className() + (name().isEmpty() ? "]" : PIStringAscii(" \"") + name() + PIStringAscii("\"]")))
#endif
@@ -116,8 +117,8 @@ enum PICoutFormat {
Dec /*! \~english Decimal representation of integers \~russian Десятичное представление для целых чисел */ = 0x04,
Hex /*! \~english Hexadecimal representation of integers \~russian Шестнадцатеричное представление для целых чисел */ = 0x08,
Bold /*! \~english Bold \~russian Жирный */ = 0x10,
Faint /*! \~english \~russian */ = 0x20,
Italic /*! \~english \~russian */ = 0x40,
Faint /*! \~english Faint \~russian Тусклый */ = 0x20,
Italic /*! \~english Italic \~russian Курсив */ = 0x40,
Underline /*! \~english Underline \~russian Подчеркнутый */ = 0x80,
Blink /*! \~english Blink \~russian Мигающий */ = 0x100,
Black /*! \~english Black font \~russian Чёрный */ = 0x400,
@@ -153,10 +154,15 @@ enum class PICoutStdStream {
};
//! \ingroup Core
//! \~\ingroup Core
//! \~\brief
//! \~english Universal output to console class.
//! \~russian Универсальный вывод в консоль.
//! \details
//! \~english This class provides a universal output interface with support for various data types, formatting options, and multiple output
//! devices (console, buffer).
//! \~russian Данный класс предоставляет универсальный интерфейс вывода с поддержкой различных типов данных, опций форматирования и
//! нескольких устройств вывода (консоль, буфер).
class PIP_EXPORT PICout {
public:
//! \~english Default constructor with default features (AddSpaces and AddNewLine)
@@ -178,10 +184,16 @@ public:
public:
//! \~english Singleton access to %PICout::Notifier
//! \~russian Синглтон класса %PICout::Notifier
//! \details
//! \~english Returns the singleton instance of the Notifier class used for emitting PICout events.
//! \~russian Возвращает синглтон-экземпляр класса Notifier, используемого для посылки событий PICout.
static Notifier * instance();
//! \~english Object that emit events from %PICout
//! \~russian Объект, который посылает события от %PICout
//! \details
//! \~english Returns the PIObject instance that emits events when PICout with external buffer is destroyed.
//! \~russian Возвращает экземпляр PIObject, который посылает события при уничтожении PICout с внешним буфером.
static PIObject * object();
private:
@@ -234,26 +246,51 @@ public:
//! \~english Output operator for <tt>"int"</tt> values
//! \~russian Оператор вывода для <tt>"int"</tt> значений
//! \details
//! \~english Outputs an integer value to the configured stream with optional format (binary, octal, decimal, hexadecimal).
//! \~russian Выводит целочисленное значение в настроенный поток с опциональным форматированием (binary, octal, decimal, hexadecimal).
PICout & operator<<(int v);
//! \~english Output operator for <tt>"unsigned int"</tt> values
//! \~russian Оператор вывода для <tt>"unsigned int"</tt> значений
//! \details
//! \~english Outputs an unsigned integer value to the configured stream with optional format (binary, octal, decimal, hexadecimal).
//! \~russian Выводит беззнаковое целочисленное значение в настроенный поток с опциональным форматированием (binary, octal, decimal,
//! hexadecimal).
PICout & operator<<(uint v);
//! \~english Output operator for <tt>"long"</tt> values
//! \~russian Оператор вывода для <tt>"long"</tt> значений
//! \details
//! \~english Outputs a long integer value to the configured stream with optional format (binary, octal, decimal, hexadecimal).
//! \~russian Выводит длинное целочисленное значение в настроенный поток с опциональным форматированием (binary, octal, decimal,
//! hexadecimal).
PICout & operator<<(long v);
//! \~english Output operator for <tt>"unsigned long"</tt> values
//! \~russian Оператор вывода для <tt>"unsigned long"</tt> значений
//! \details
//! \~english Outputs an unsigned long integer value to the configured stream with optional format (binary, octal, decimal,
//! hexadecimal).
//! \~russian Выводит беззнаковое длинное целочисленное значение в настроенный поток с опциональным форматированием (binary, octal,
//! decimal, hexadecimal).
PICout & operator<<(ulong v);
//! \~english Output operator for <tt>"long long"</tt> values
//! \~russian Оператор вывода для <tt>"long long"</tt> значений
//! \details
//! \~english Outputs a long long integer value to the configured stream with optional format (binary, octal, decimal, hexadecimal).
//! \~russian Выводит длинное long long целочисленное значение в настроенный поток с опциональным форматированием (binary, octal,
//! decimal, hexadecimal).
PICout & operator<<(llong v);
//! \~english Output operator for <tt>"unsigned long long"</tt> values
//! \~russian Оператор вывода для <tt>"unsigned long long"</tt> значений
//! \details
//! \~english Outputs an unsigned long long integer value to the configured stream with optional format (binary, octal, decimal,
//! hexadecimal).
//! \~russian Выводит беззнаковое длинное long long целочисленное значение в настроенный поток с опциональным форматированием (binary,
//! octal, decimal, hexadecimal).
PICout & operator<<(ullong v);
//! \~english Output operator for <tt>"float"</tt> values
@@ -270,10 +307,16 @@ public:
//! \~english Output operator for pointers
//! \~russian Оператор вывода для указателей
//! \details
//! \~english Outputs a pointer address to the configured stream in hexadecimal format.
//! \~russian Выводит адрес указателя в настроенный поток в шестнадцатеричном формате.
PICout & operator<<(const void * v);
//! \~english Output operator for PIObject and ancestors
//! \~russian Оператор вывода для PIObject и наследников
//! \details
//! \~english Outputs a PIObject or its descendants to the configured stream, including class name and object name.
//! \~russian Выводит PIObject или его наследников в настроенный поток, включая имя класса и имя объекта.
PICout & operator<<(const PIObject * v);
//! \~english Output operator for \a PICoutSpecialChar values
@@ -282,10 +325,18 @@ public:
//! \~english Output operator for \a PIFlags<PICoutFormat> values
//! \~russian Оператор вывода для \a PIFlags<PICoutFormat>
//! \details
//! \~english Sets output format flags (binary, octal, decimal, hexadecimal, bold, colors) for subsequent integer output.
//! \~russian Устанавливает флаги форматирования вывода (binary, octal, decimal, hexadecimal, bold, colors) для последующего вывода
//! целых чисел.
PICout & operator<<(PIFlags<PICoutManipulators::PICoutFormat> v);
//! \~english Output operator for \a PICoutFormat values
//! \~russian Оператор вывода для \a PICoutFormat
//! \details
//! \~english Sets output format flag (binary, octal, decimal, hexadecimal, bold, colors) for subsequent integer output.
//! \~russian Устанавливает флаг форматирования вывода (binary, octal, decimal, hexadecimal, bold, colors) для последующего вывода целых
//! чисел.
PICout & operator<<(PICoutManipulators::PICoutFormat v);
//! \~english Do some action
@@ -301,45 +352,72 @@ public:
PICout & setControls(PICoutManipulators::PICoutControls c);
//! \~english Exec \a saveControls() and set control flags to "c"
//! \~russian Иыполнить \a saveControls() и Установить флаги "c"
//! \~russian Выполнить \a saveControls() и установить флаги "c"
PICout & saveAndSetControls(PICoutManipulators::PICoutControls c);
//! \~english Save control flags to internal stack
//! \~russian Сохраняет состояние флагов во внутренний стек
//! \~\sa \a restoreControl()
//! \details
//! \~english Saves the current control flags to an internal stack for later restoration using restoreControls().
//! \~russian Сохраняет текущие флаги управления во внутренний стек для последующего восстановления с помощью restoreControls().
//! \~\sa \a restoreControls()
PICout & saveControls();
//! \~english Restore control flags from internal stack
//! \~russian Восстанавливает состояние флагов из внутреннего стека
//! \~\sa \a saveControl()
//! \details
//! \~english Restores the control flags from the internal stack that were previously saved using saveControls().
//! \~russian Восстанавливает флаги управления из внутреннего стека, которые были ранее сохранены с помощью saveControls().
//! \~\sa \a saveControls()
PICout & restoreControls();
//! \~english Conditional put space character to output
//! \~russian Условно добавляет пробел
//! \details
//! \~english Conditionally adds a space character to the output if the AddSpaces control flag is enabled.
//! \~russian Условно добавляет пробел в вывод, если включен флаг управления AddSpaces.
PICout & space();
//! \~english Conditional put quote character to output
//! \~russian Условно добавляет кавычки
//! \details
//! \~english Conditionally adds quote characters to the output if the AddQuotes control flag is enabled.
//! \~russian Условно добавляет кавычки в вывод, если включен флаг управления AddQuotes.
PICout & quote();
//! \~english Conditional put new line character to output
//! \~russian Условно добавляет новую строку
//! \details
//! \~english Conditionally adds a newline character to the output if the AddNewLine control flag is enabled.
//! \~russian Условно добавляет символ новой строки в вывод, если включен флаг управления AddNewLine.
PICout & newLine();
//! \~english Write char
//! \~russian Пишет символ
//! \details
//! \~english Writes a single character directly to the output stream without any formatting.
//! \~russian Записывает один символ непосредственно в поток вывода без какого-либо форматирования.
PICout & write(char c);
//! \~english Write raw data
//! \~russian Пишет сырые символы
//! \details
//! \~english Writes raw C-style string data directly to the output stream without any formatting.
//! \~russian Записывает сырые данные C-строки непосредственно в поток вывода без какого-либо форматирования.
PICout & write(const char * str);
//! \~english Write raw data
//! \~russian Пишет сырые символы
//! \details
//! \~english Writes raw data of specified length directly to the output stream without any formatting.
//! \~russian Записывает сырые данные указанной длины непосредственно в поток вывода без какого-либо форматирования.
PICout & write(const char * str, int len);
//! \~english Write raw \a PIString
//! \~russian Пишет сырой \a PIString
//! \details
//! \~english Writes raw PIString data directly to the output stream without any formatting.
//! \~russian Записывает сырые данные PIString непосредственно в поток вывода без какого-либо форматирования.
PICout & write(const PIString & s);
//! \~english Output \a PIString to stdout
@@ -386,14 +464,22 @@ public:
//! \~english Construct with external buffer.
//! \~russian Конструктор с внешним буфером.
//! \details
//! \~english Creates a PICout instance that outputs to an external PIString buffer with specified control flags.
//! \~russian Создает экземпляр PICout, который выводит данные во внешний буфер PIString с указанными флагами управления.
static PICout withExternalBuffer(PIString * buffer,
PIFlags<PICoutManipulators::PICoutControl> controls = PICoutManipulators::AddSpaces);
PIFlags<PICoutManipulators::PICoutControl> controls = PICoutManipulators::AddSpaces);
//! \~english Construct with external buffer and ID "id". See \a Notifier for details
//! \~russian Конструктор с внешним буфером и ID "id". Подробнее \a Notifier
//! \details
//! \~english Creates a PICout instance with external buffer and notification ID. When the last copy is destroyed, it emits a finished()
//! event via Notifier.
//! \~russian Создает экземпляр PICout с внешним буфером и идентификатором уведомления. При уничтожении последней копии посылается
//! событие finished() через Notifier.
static PICout withExternalBufferAndID(PIString * buffer,
int id,
PIFlags<PICoutManipulators::PICoutControl> controls = PICoutManipulators::DefaultControls);
int id,
PIFlags<PICoutManipulators::PICoutControl> controls = PICoutManipulators::DefaultControls);
//! \~english Returns unique external buffer ID for later use in \a withExternalBufferAndID()
//! \~russian Возвращает уникальный ID для внешнего буфера для дальнейшего использования в \a withExternalBufferAndID()

43
libs/main/core/piincludes.h
View File

@@ -1,8 +1,8 @@
/*! \file piincludes.h
* \ingroup Core
* \~\brief
* \~english Minimal PIP includes
* \~russian Минимально-необходимые инклюды PIP
* \~english Core includes and low-level helper functions
* \~russian Базовые включения и низкоуровневые вспомогательные функции
*/
/*
PIP - Platform Independent Primitives
@@ -50,27 +50,42 @@ class PIWaitEvent;
struct lconv;
//! \~\ingroup Core
//! \~\brief
//! \~english Pointer to current C locale numeric settings
//! \~russian Указатель на текущие числовые настройки C locale
extern PIP_EXPORT lconv * currentLocale;
//! \ingroup Core
//! \brief
//! \~english Return readable error description in format "code <number> - <description>"
//! \~russian Возвращает читаемое описание ошибки в формате "code <номер> - <описание>"
//! \~\ingroup Core
//! \~\brief
//! \~english Returns readable description of the last system error in format
//! "code <number> - <description>"
//! \~russian Возвращает читаемое описание последней системной ошибки в формате
//! "code <номер> - <описание>"
PIP_EXPORT PIString errorString();
//! \ingroup Core
//! \brief
//! \~english Reset last error
//! \~russian Сброс последней ошибки
//! \~\ingroup Core
//! \~\brief
//! \~english Clears the last system error
//! \~russian Сбрасывает последнюю системную ошибку
PIP_EXPORT void errorClear();
//! \~\ingroup Core
//! \~\brief
//! \~english Seeds the global pseudo-random generator
//! \~russian Инициализирует глобальный генератор псевдослучайных чисел
PIP_EXPORT void randomize();
//! \~\ingroup Core
//! \~\brief
//! \~english Returns next value from the global pseudo-random generator
//! \~russian Возвращает следующее значение глобального генератора псевдослучайных чисел
PIP_EXPORT int randomi();
//! \ingroup Core
//! \brief
//! \~english Return readable version of PIP
//! \~russian Возвращает читаемую версию PIP
//! \~\ingroup Core
//! \~\brief
//! \~english Returns readable PIP version string
//! \~russian Возвращает строку версии PIP
PIP_EXPORT PIString PIPVersion();
#endif // PIINCLUDES_H

42
libs/main/core/piinit.h
View File

@@ -1,9 +1,12 @@
/*! \file piinit.h
* \ingroup Core
* \~\brief
* \~english Library initialization
* \~russian Инициализация библиотеки
*/
//! \~\ingroup Core
//! \~\file piinit.h
//! \~\brief
//! \~english Library initialization
//! \~russian Инициализация библиотеки
//! \details
//! \~english This file provides initialization and build information for the PIP library.
//! \~russian Этот файл предоставляет инициализацию и информацию о сборке для библиотеки PIP.//! \}
/*
PIP - Platform Independent Primitives
Initialization
@@ -36,7 +39,6 @@
class PIFile;
class PIStringList;
class PIP_EXPORT __PIInit_Initializer__ {
public:
__PIInit_Initializer__();
@@ -47,7 +49,10 @@ public:
static __PIInit_Initializer__ __piinit_initializer__;
//! \~\ingroup Core
//! \~\brief
//! \~english Library initialization singleton and build information access point.
//! \~russian Синглтон инициализации библиотеки и точка доступа к сведениям о сборке.
class PIP_EXPORT PIInit {
friend class __PIInit_Initializer__;
friend class PIFile;
@@ -55,9 +60,9 @@ class PIP_EXPORT PIInit {
public:
~PIInit();
//! \ingroup Core
//! \~english Build options which PIP library was built
//! \~russian Опции, с которыми был собран PIP
//! \~\ingroup Core
//! \~english Build options enabled in the current PIP library
//! \~russian Опции, включенные в текущей сборке библиотеки PIP
enum BuildOption {
boICU /*! \~english Unicode support by ICU \~russian Поддержка юникода через ICU */ = 0x01,
boUSB /*! \~english USB support \~russian Поддержка USB */ = 0x02,
@@ -69,16 +74,19 @@ public:
boCloud /*! \~english PICloud transport support \~russian Поддержка облачного транспорта PICloud */ = 0x200,
boConsole /*! \~english Console graphics support \~russian Поддержка графики в консоли */ = 0x400,
};
//! \~english Returns current global %PIInit instance.
//! \~russian Возвращает текущий глобальный экземпляр %PIInit.
static PIInit * instance() { return __PIInit_Initializer__::__instance__; }
//! \ingroup Core
//! \~english Returns if build option was enabled
//! \~russian Возвращает была ли включена опция при сборке
//! \~\ingroup Core
//! \~english Returns whether build option was enabled
//! \~russian Возвращает, была ли опция включена при сборке
static bool isBuildOptionEnabled(BuildOption o);
//! \ingroup Core
//! \~english Returns build options as stringlist
//! \~russian Возвращает опции сборки как список строк
//! \~\ingroup Core
//! \~english Returns enabled build options as string list
//! \~russian Возвращает включенные опции сборки в виде списка строк
static PIStringList buildOptions();
private:

61
libs/main/core/pimemoryblock.h
View File

@@ -1,9 +1,15 @@
/*! \file pimemoryblock.h
* \ingroup Core
* \~\brief
* \~english Base types and functions
* \~russian Базовые типы и методы
*/
//! \~\ingroup Core
//! \~\file pimemoryblock.h
//! \brief
//! \~english Memory block helper struct for data storage and binary stream operations
//! \~russian Вспомогательная структура памяти для хранения данных и операций с двоичным потоком
//! \details
//! \~english The PIMemoryBlock struct provides a lightweight wrapper to store and restore custom blocks of data to/from PIBinaryStream. It
//! holds a pointer to data and its size in bytes.
//! \~russian Структура PIMemoryBlock предоставляет легковесный wrapper для сохранения и извлечения произвольных блоков данных в/из
//! PIBinaryStream. Она содержит указатель на данные и их размер в байтах.
/*
PIP - Platform Independent Primitives
Base types and functions
@@ -27,49 +33,52 @@
#define PIMEMORYBLOCK_H
//! \ingroup Core
//! \include pimemoryblock.h
//! \brief
//! \~english Help struct to store/restore custom blocks of data to/from PIBinaryStream
//! \~russian Вспомогательная структура для сохранения/извлечения произвольного блока данных в/из PIBinaryStream
//! \~\brief
//! \~english Helper struct to store and restore custom blocks of data to/from PIBinaryStream
//! \~russian Вспомогательная структура для сохранения и извлечения произвольных блоков данных в/из PIBinaryStream
struct PIMemoryBlock {
public:
//! \~english Constructs data block
//! \~russian Создает блок данных
//! \~english Constructs empty memory block.
//! \~russian Создает пустой блок памяти.
PIMemoryBlock() {}
//! \~english Constructs data block
//! \~russian Создает блок данных
//! \~english Constructs memory block from pointer and size.
//! \~russian Создает блок памяти из указателя и размера.
PIMemoryBlock(const void * data_, const int size_) {
d = const_cast<void *>(data_);
s = size_;
}
//! \~english Copy constructor.
//! \~russian Конструктор копирования.
PIMemoryBlock(const PIMemoryBlock & o) {
d = o.d;
s = o.s;
}
//! \~english Copy assignment operator.
//! \~russian Оператор присваивания копированием.
PIMemoryBlock & operator=(const PIMemoryBlock & o) {
d = o.d;
s = o.s;
return *this;
}
//! \~english Pointer to data
//! \~russian Указатель на данные
//! \~english Returns pointer to block data.
//! \~russian Возвращает указатель на данные блока.
void * data() { return d; }
//! \~english Pointer to data
//! \~russian Указатель на данные
//! \~english Returns pointer to block data.
//! \~russian Возвращает указатель на данные блока.
const void * data() const { return d; }
//! \~english Size of data in bytes
//! \~russian Размер данных в байтах
//! \~english Returns block size in bytes.
//! \~russian Возвращает размер блока в байтах.
int size() const { return s; }
//! \~english Returns if this block points to nothing
//! \~russian Возвращает пустой ли указатель на данные
//! \~english Returns `true` when the block stores a non-null pointer.
//! \~russian Возвращает `true`, когда блок хранит ненулевой указатель.
bool isNull() const { return d; }
private:
@@ -77,8 +86,10 @@ private:
int s = 0;
};
//! \~english Returns PIMemoryBlock from pointer to variable "ptr" with type "T"
//! \~russian Возвращает PIMemoryBlock из указателя "ptr" типа "T"
//! \~\ingroup Core
//! \~\brief
//! \~english Creates %PIMemoryBlock for object pointed by "ptr".
//! \~russian Создает %PIMemoryBlock для объекта, на который указывает "ptr".
template<typename T>
PIMemoryBlock createMemoryBlock(const T * ptr) {
return PIMemoryBlock(ptr, sizeof(T));

330
libs/main/core/piobject.h
View File

@@ -1,9 +1,8 @@
/*! \file piobject.h
* \ingroup Core
* \~\brief
* \~english Base object
* \~russian Базовый класс
*/
//! \~\ingroup Core
//! \~\file piobject.h
//! \~\brief
//! \~english Base object class providing event -> handler mechanism
//! \~russian Базовый класс объектов, обеспечивающий механизм событий -> обработчиков
/*
PIP - Platform Independent Primitives
Object, base class of some PIP classes, provide EVENT -> EVENT_HANDLER mechanism
@@ -34,10 +33,26 @@
#include "pivariant.h"
#include "pivariantsimple.h"
//! \ingroup Core
//! \~\ingroup Core
//! \~\brief
//! \~english This is base class for any classes which use events -> handlers mechanism.
//! \~russian Этот класс является базовым для использования механизма события -> обработчики.
//! \~english Base class for objects that declare events, event handlers and registered methods.
//! \~russian Базовый класс для объектов, которые объявляют события, обработчики событий и зарегистрированные методы.
//! \~\details
//! \~english
//! PIObject is the base class for all PIP classes that need event-driven communication.
//! It provides signal-slot mechanism, property system, and object lifetime management.
//! %PIObject stores named properties, keeps connection state and exposes a
//! small metaobject table used by \a CONNECTU(), \a execute() and related APIs.
//! Queued delivery runs on the performer object and requires explicit draining
//! through \a callQueuedEvents() or \a maybeCallQueuedEvents().
//! \~russian
//! PIObject является базовым классом для всех классов PIP, которым необходима событийная коммуникация.
//! Он обеспечивает механизм сигналов-слотов, систему свойств и управление жизненным циклом объектов.
//! %PIObject хранит именованные свойства, состояние соединений и небольшую
//! метаобъектную таблицу, которую используют \a CONNECTU(), \a execute() и
//! связанные методы. Отложенная доставка выполняется на объекте-исполнителе и
//! требует явного опустошения очереди через \a callQueuedEvents() или
//! \a maybeCallQueuedEvents().
class PIP_EXPORT PIObject {
#ifndef MICRO_PIP
friend class PIObjectManager;
@@ -50,16 +65,18 @@ class PIP_EXPORT PIObject {
public:
NO_COPY_CLASS(PIObject);
//! \~english Contructs %PIObject with name "name"
//! \~russian Создает %PIObject с именем "name"
//! \~english Constructs an object and initializes its \c name property.
//! \~russian Создает объект и инициализирует его свойство \c name.
explicit PIObject(const PIString & name = PIString());
//! \~english Destroys the object, raises \a deleted() and disconnects it from the event graph.
//! \~russian Уничтожает объект, вызывает \a deleted() и отключает его от событийного графа.
virtual ~PIObject();
//! \ingroup Core
//! \~\ingroup Core
//! \~\brief
//! \~english Helper class for obtain info about if connection successful and disconnect single connection.
//! \~russian Вспомогательный класс для получения информации об успешности соединения и возможности его разрыва.
//! \~english Handle of one connection between a source object and a destination object or functor.
//! \~russian Дескриптор одного соединения между объектом-источником и объектом-приемником либо функтором.
class PIP_EXPORT Connection {
friend class PIObject;
Connection(void * sl,
@@ -93,28 +110,31 @@ public:
int args_count;
public:
//! \~english Contructs invalid %Connection
//! \~russian Создает недействительный %Connection
//! \~english Constructs an invalid connection handle.
//! \~russian Создает недействительный дескриптор соединения.
Connection();
//! \~english Returns if %Connection is valid
//! \~russian Возвращает успешен ли %Connection
//! \~english Returns \c true when the connection was created successfully.
//! \~russian Возвращает \c true, если соединение было успешно создано.
bool isValid() const { return signal; }
//! \~english Returns source object
//! \~russian Возвращает объект-источник
//! \~english Returns the source object that emits the event.
//! \~russian Возвращает объект-источник, который испускает событие.
PIObject * sourceObject() const { return src_o; }
//! \~english Returns destination object or "nullptr" if this is lambda connection
//! \~russian Возвращает объект-приемник или "nullptr" если это соединение на лямбда-функцию
//! \~english Returns the destination object, or \c nullptr for a lambda connection.
//! \~russian Возвращает объект-приемник, либо \c nullptr для соединения с лямбда-функцией.
PIObject * destinationObject() const { return dest_o; }
//! \~english Returns performer object or "nullptr" if this is non-queued connection
//! \~russian Возвращает объект-исполнитель или "nullptr" если это соединение не отложенное
//! \~english Returns the performer object, or \c nullptr for direct delivery.
//! \~russian Возвращает объект-исполнитель, либо \c nullptr для прямой доставки.
//! \~\details
//! \~english Queued delivery runs only when the performer drains its queue.
//! \~russian Отложенная доставка выполняется только когда исполнитель обрабатывает свою очередь.
PIObject * performerObject() const { return performer; }
//! \~english Disconnect this %Connection, returns if operation successful
//! \~russian Разрывает этот %Connection, возвращает успешен ли разрыв
//! \~english Disconnects this single connection.
//! \~russian Разрывает только это соединение.
bool disconnect() const;
};
@@ -122,14 +142,16 @@ private:
uint _signature_;
public:
//! \~english Returns object name
//! \~russian Возвращает имя объекта
//! \~english Returns the \c name property of this object.
//! \~russian Возвращает свойство \c name этого объекта.
PIString name() const { return property("name").toString(); }
//! \~english Returns object class name
//! \~russian Возвращает имя класса объекта
//! \~english Returns the registered class name of this object.
//! \~russian Возвращает зарегистрированное имя класса этого объекта.
virtual const char * className() const { return "PIObject"; }
//! \~english Returns the hash of \a className().
//! \~russian Возвращает хэш от \a className().
virtual uint classNameID() const {
static uint ret = PIStringAscii("PIObject").hash();
return ret;
@@ -141,51 +163,87 @@ public:
return ret;
}
//! \~english Returns parent class name
//! \~russian Возвращает имя родительского класса
//! \~english Returns the registered parent class name, or an empty string for the root.
//! \~russian Возвращает зарегистрированное имя родительского класса, либо пустую строку для корня.
virtual const char * parentClassName() const { return ""; }
//! \~english Return if \a piCoutObj of this object is active
//! \~russian Возвращает включен ли вывод \a piCoutObj для этого объекта
//! \~english Returns whether \a piCoutObj output is enabled for this object.
//! \~russian Возвращает, включен ли вывод \a piCoutObj для этого объекта.
bool debug() const { return property("debug").toBool(); }
//! \~english Set object name
//! \~russian Устанавливает имя объекта
//! \~english Sets the \c name property of this object.
//! \~russian Устанавливает свойство \c name этого объекта.
void setName(const PIString & name) { setProperty("name", name); }
//! \~english Set object \a piCoutObj active
//! \~russian Включает или отключает вывод \a piCoutObj для этого объекта
//! \~english Enables or disables \a piCoutObj output for this object.
//! \~russian Включает или отключает вывод \a piCoutObj для этого объекта.
void setDebug(bool debug) { setProperty("debug", debug); }
//! \~english Returns property with name "name"
//! \~russian Возвращает свойство объекта по имени "name"
//! \~english Returns the property with name "name".
//! \~russian Возвращает свойство объекта по имени "name".
PIVariant property(const char * name) const { return properties_.value(piHashData((const uchar *)name, strlen(name))); }
//! \~english Set property with name "name" to "value". If there is no such property in object it will be added
//! \~russian Устанавливает у объекта свойство по имени "name" в "value". Если такого свойства нет, оно добавляется
//! \~english Sets the property "name" to "value" and creates it if needed.
//! \~russian Устанавливает свойство "name" в значение "value" и создаёт его при необходимости.
//! \~\details
//! \~english Calls \a propertyChanged() after updating the stored value.
//! \~russian После обновления сохранённого значения вызывает \a propertyChanged().
void setProperty(const char * name, const PIVariant & value) {
properties_[piHashData((const uchar *)name, strlen(name))] = value;
propertyChanged(name);
}
//! \~english Returns if property with name "name" exists
//! \~russian Возвращает присутствует ли свойство по имени "name"
//! \~english Returns whether the property "name" exists.
//! \~russian Возвращает, существует ли свойство "name".
bool isPropertyExists(const char * name) const { return properties_.contains(piHashData((const uchar *)name, strlen(name))); }
//! \~english Enables or disables the internal object mutex during handler execution.
//! \~russian Включает или отключает внутренний мьютекс объекта во время выполнения обработчиков.
//! \~\details
//! \~english This flag affects direct and queued handler invocation for this object, but does not describe full thread-safety of the
//! class.
//! \~russian Этот флаг влияет на прямой и отложенный вызов обработчиков для данного объекта, но не описывает полную потокобезопасность
//! класса.
void setThreadSafe(bool yes) { thread_safe_ = yes; }
//! \~english Returns whether the internal object mutex is enabled for handler execution.
//! \~russian Возвращает, включен ли внутренний мьютекс объекта для выполнения обработчиков.
bool isThreadSafe() const { return thread_safe_; }
//! \~english Executes a registered method or handler method by name with the supplied arguments.
//! \~russian Выполняет зарегистрированный метод или метод-обработчик по имени с переданными аргументами.
//! \~\details
//! \~english
//! This helper works only with the registered-method table built from
//! \a EVENT_HANDLER*() and \a EVENT*() declarations. It does not provide
//! arbitrary reflection or complex overload resolution: the implementation
//! selects a suitable registered method by name and argument count.
//! \~russian
//! Этот вспомогательный метод работает только с таблицей зарегистрированных
//! методов, построенной из объявлений \a EVENT_HANDLER*() и \a EVENT*().
//! Он не предоставляет произвольную рефлексию и сложное разрешение
//! перегрузок: реализация выбирает подходящий зарегистрированный метод по
//! имени и числу аргументов.
bool execute(const PIString & method, const PIVector<PIVariantSimple> & vl);
//! \~english Overload of \a execute() for a method without arguments.
//! \~russian Перегрузка \a execute() для метода без аргументов.
bool execute(const PIString & method) { return execute(method, PIVector<PIVariantSimple>()); }
//! \~english Overload of \a execute() for one argument.
//! \~russian Перегрузка \a execute() для одного аргумента.
bool execute(const PIString & method, const PIVariantSimple & v0) { return execute(method, PIVector<PIVariantSimple>() << v0); }
//! \~english Overload of \a execute() for two arguments.
//! \~russian Перегрузка \a execute() для двух аргументов.
bool execute(const PIString & method, const PIVariantSimple & v0, const PIVariantSimple & v1) {
return execute(method, PIVector<PIVariantSimple>() << v0 << v1);
}
//! \~english Overload of \a execute() for three arguments.
//! \~russian Перегрузка \a execute() для трёх аргументов.
bool execute(const PIString & method, const PIVariantSimple & v0, const PIVariantSimple & v1, const PIVariantSimple & v2) {
return execute(method, PIVector<PIVariantSimple>() << v0 << v1 << v2);
}
//! \~english Overload of \a execute() for four arguments.
//! \~russian Перегрузка \a execute() для четырёх аргументов.
bool execute(const PIString & method,
const PIVariantSimple & v0,
const PIVariantSimple & v1,
@@ -194,16 +252,36 @@ public:
return execute(method, PIVector<PIVariantSimple>() << v0 << v1 << v2 << v3);
}
//! \~english Queues execution of a registered method on the performer object.
//! \~russian Ставит выполнение зарегистрированного метода в очередь объекта-исполнителя.
//! \~\details
//! \~english
//! Delivery happens only when "performer" later calls \a callQueuedEvents()
//! or \a maybeCallQueuedEvents(). Argument values are transported through
//! \a PIVariantSimple, so queued arguments should be representable there.
//! \~russian
//! Доставка происходит только когда "performer" позже вызывает
//! \a callQueuedEvents() или \a maybeCallQueuedEvents(). Значения аргументов
//! передаются через \a PIVariantSimple, поэтому аргументы очереди должны в
//! нём представляться.
bool executeQueued(PIObject * performer, const PIString & method, const PIVector<PIVariantSimple> & vl);
//! \~english Overload of \a executeQueued() for a method without arguments.
//! \~russian Перегрузка \a executeQueued() для метода без аргументов.
bool executeQueued(PIObject * performer, const PIString & method) {
return executeQueued(performer, method, PIVector<PIVariantSimple>());
}
//! \~english Overload of \a executeQueued() for one argument.
//! \~russian Перегрузка \a executeQueued() для одного аргумента.
bool executeQueued(PIObject * performer, const PIString & method, const PIVariantSimple & v0) {
return executeQueued(performer, method, PIVector<PIVariantSimple>() << v0);
}
//! \~english Overload of \a executeQueued() for two arguments.
//! \~russian Перегрузка \a executeQueued() для двух аргументов.
bool executeQueued(PIObject * performer, const PIString & method, const PIVariantSimple & v0, const PIVariantSimple & v1) {
return executeQueued(performer, method, PIVector<PIVariantSimple>() << v0 << v1);
}
//! \~english Overload of \a executeQueued() for three arguments.
//! \~russian Перегрузка \a executeQueued() для трёх аргументов.
bool executeQueued(PIObject * performer,
const PIString & method,
const PIVariantSimple & v0,
@@ -211,6 +289,8 @@ public:
const PIVariantSimple & v2) {
return executeQueued(performer, method, PIVector<PIVariantSimple>() << v0 << v1 << v2);
}
//! \~english Overload of \a executeQueued() for four arguments.
//! \~russian Перегрузка \a executeQueued() для четырёх аргументов.
bool executeQueued(PIObject * performer,
const PIString & method,
const PIVariantSimple & v0,
@@ -220,18 +300,30 @@ public:
return executeQueued(performer, method, PIVector<PIVariantSimple>() << v0 << v1 << v2 << v3);
}
//! \~english Static convenience wrapper for \a execute().
//! \~russian Статическая удобная обёртка над \a execute().
static bool execute(PIObject * o, const PIString & method, const PIVector<PIVariantSimple> & vl) { return o->execute(method, vl); }
//! \~english Static overload of \a execute() without arguments.
//! \~russian Статическая перегрузка \a execute() без аргументов.
static bool execute(PIObject * o, const PIString & method) { return execute(o, method, PIVector<PIVariantSimple>()); }
//! \~english Static overload of \a execute() for one argument.
//! \~russian Статическая перегрузка \a execute() для одного аргумента.
static bool execute(PIObject * o, const PIString & method, const PIVariantSimple & v0) {
return execute(o, method, PIVector<PIVariantSimple>() << v0);
}
//! \~english Static overload of \a execute() for two arguments.
//! \~russian Статическая перегрузка \a execute() для двух аргументов.
static bool execute(PIObject * o, const PIString & method, const PIVariantSimple & v0, const PIVariantSimple & v1) {
return execute(o, method, PIVector<PIVariantSimple>() << v0 << v1);
}
//! \~english Static overload of \a execute() for three arguments.
//! \~russian Статическая перегрузка \a execute() для трёх аргументов.
static bool
execute(PIObject * o, const PIString & method, const PIVariantSimple & v0, const PIVariantSimple & v1, const PIVariantSimple & v2) {
return execute(o, method, PIVector<PIVariantSimple>() << v0 << v1 << v2);
}
//! \~english Static overload of \a execute() for four arguments.
//! \~russian Статическая перегрузка \a execute() для четырёх аргументов.
static bool execute(PIObject * o,
const PIString & method,
const PIVariantSimple & v0,
@@ -241,19 +333,29 @@ public:
return execute(o, method, PIVector<PIVariantSimple>() << v0 << v1 << v2 << v3);
}
//! \~english Static convenience wrapper for \a executeQueued().
//! \~russian Статическая удобная обёртка над \a executeQueued().
static bool executeQueued(PIObject * o, PIObject * performer, const PIString & method, const PIVector<PIVariantSimple> & vl) {
return o->executeQueued(performer, method, vl);
}
//! \~english Static overload of \a executeQueued() without arguments.
//! \~russian Статическая перегрузка \a executeQueued() без аргументов.
static bool executeQueued(PIObject * o, PIObject * performer, const PIString & method) {
return executeQueued(o, performer, method, PIVector<PIVariantSimple>());
}
//! \~english Static overload of \a executeQueued() for one argument.
//! \~russian Статическая перегрузка \a executeQueued() для одного аргумента.
static bool executeQueued(PIObject * o, PIObject * performer, const PIString & method, const PIVariantSimple & v0) {
return executeQueued(o, performer, method, PIVector<PIVariantSimple>() << v0);
}
//! \~english Static overload of \a executeQueued() for two arguments.
//! \~russian Статическая перегрузка \a executeQueued() для двух аргументов.
static bool
executeQueued(PIObject * o, PIObject * performer, const PIString & method, const PIVariantSimple & v0, const PIVariantSimple & v1) {
return executeQueued(o, performer, method, PIVector<PIVariantSimple>() << v0 << v1);
}
//! \~english Static overload of \a executeQueued() for three arguments.
//! \~russian Статическая перегрузка \a executeQueued() для трёх аргументов.
static bool executeQueued(PIObject * o,
PIObject * performer,
const PIString & method,
@@ -262,6 +364,8 @@ public:
const PIVariantSimple & v2) {
return executeQueued(o, performer, method, PIVector<PIVariantSimple>() << v0 << v1 << v2);
}
//! \~english Static overload of \a executeQueued() for four arguments.
//! \~russian Статическая перегрузка \a executeQueued() для четырёх аргументов.
static bool executeQueued(PIObject * o,
PIObject * performer,
const PIString & method,
@@ -272,22 +376,37 @@ public:
return executeQueued(o, performer, method, PIVector<PIVariantSimple>() << v0 << v1 << v2 << v3);
}
//! \~english Dumps object diagnostics to the project output stream.
//! \~russian Выводит диагностическую информацию об объекте в проектный поток вывода.
void dump(const PIString & line_prefix = PIString()) const;
//! \~english Returns subclass scope of this object (including this class name)
//! \~russian Возвращает цепочку наследования объекта (вместе с классом самого объекта)
//! \~english Returns the registered inheritance scope of this object, including its own class.
//! \~russian Возвращает зарегистрированную цепочку наследования объекта, включая его собственный класс.
PIStringList scopeList() const;
//! \~english Returns full signatures of all registered event and handler methods for this class scope.
//! \~russian Возвращает полные сигнатуры всех зарегистрированных событий и обработчиков для области этого класса.
PIStringList methodsEH() const;
//! \~english Returns whether a registered event or handler method with this name exists.
//! \~russian Возвращает, существует ли зарегистрированное событие или обработчик с таким именем.
bool isMethodEHContains(const PIString & name) const;
//! \~english Returns the comma-separated argument type list of a registered method.
//! \~russian Возвращает список типов аргументов зарегистрированного метода через запятую.
PIString methodEHArguments(const PIString & name) const;
//! \~english Returns the full registered signature of a method.
//! \~russian Возвращает полную зарегистрированную сигнатуру метода.
PIString methodEHFullFormat(const PIString & name) const;
//! \~english Returns the registered method name for the specified entry-point address.
//! \~russian Возвращает имя зарегистрированного метода для указанного адреса точки входа.
PIString methodEHFromAddr(const void * addr) const;
// / Direct connect
//! \~english Low-level direct connection helper behind the legacy \c CONNECT* macros.
//! \~russian Низкоуровневый помощник прямого соединения, лежащий под устаревшими макросами \c CONNECT*.
static PIObject::Connection
piConnect(PIObject * src, const PIString & sig, PIObject * dest_o, void * dest, void * ev_h, void * e_h, int args, const char * loc);
//! \~english Low-level name-based connection helper behind \a CONNECTU() and \a CONNECTU_QUEUED().
//! \~russian Низкоуровневый помощник соединения по имени, лежащий под \a CONNECTU() и \a CONNECTU_QUEUED().
static PIObject::Connection piConnectU(PIObject * src,
const PIString & sig,
PIObject * dest_o,
@@ -295,6 +414,8 @@ public:
const PIString & hname,
const char * loc,
PIObject * performer = 0);
//! \~english Low-level helper that connects an event to a lambda or functor wrapper.
//! \~russian Низкоуровневый помощник, который соединяет событие с лямбдой или обёрткой функтора.
static PIObject::Connection piConnectLS(PIObject * src, const PIString & sig, std::function<void()> * f, const char * loc);
template<typename PIINPUT, typename... PITYPES>
static std::function<void()> * __newFunctor(void (*stat_handler)(void *, PITYPES...), PIINPUT functor) {
@@ -302,33 +423,33 @@ public:
}
//! \~english Disconnect object from all connections with event name "sig", connected to destination object "dest" and handler "ev_h"
//! \~russian Разрывает все соединения от события "sig" к объекту "dest" и обработчику "ev_h"
//! \~english Disconnects this source object from a specific destination handler for event "sig".
//! \~russian Разрывает соединения этого объекта-источника с конкретным обработчиком объекта-приемника для события "sig".
void piDisconnect(const PIString & sig, PIObject * dest, void * ev_h) { piDisconnect(this, sig, dest, ev_h); }
//! \~english Disconnect object from all connections with event name "sig", connected to destination object "dest"
//! \~russian Разрывает все соединения от события "sig" к объекту "dest"
//! \~english Disconnects this source object from all connections of event "sig" to destination object "dest".
//! \~russian Разрывает все соединения этого объекта-источника от события "sig" к объекту-приемнику "dest".
void piDisconnect(const PIString & sig, PIObject * dest) { piDisconnect(this, sig, dest); }
//! \~english Disconnect object from all connections with event name "sig"
//! \~russian Разрывает все соединения от события "sig"
//! \~english Disconnects this source object from all connections of event "sig".
//! \~russian Разрывает все соединения этого объекта-источника от события "sig".
void piDisconnect(const PIString & sig) { piDisconnect(this, sig); }
//! \~english Disconnect object "src" from all connections with event name "sig", connected to destination object "dest" and handler
//! "ev_h"
//! \~russian Разрывает все соединения от события "sig" объекта "src" к объекту "dest" и обработчику "ev_h"
//! \~english Disconnects source object "src" from a specific destination handler for event "sig".
//! \~russian Разрывает соединения объекта-источника "src" с конкретным обработчиком объекта-приемника для события "sig".
static void piDisconnect(PIObject * src, const PIString & sig, PIObject * dest, void * ev_h);
//! \~english Disconnect object "src" from all connections with event name "sig", connected to destination object "dest"
//! \~russian Разрывает все соединения от события "sig" объекта "src" к объекту "dest"
//! \~english Disconnects source object "src" from all connections of event "sig" to destination object "dest".
//! \~russian Разрывает все соединения объекта-источника "src" от события "sig" к объекту-приемнику "dest".
static void piDisconnect(PIObject * src, const PIString & sig, PIObject * dest);
//! \~english Disconnect object "src" from all connections with event name "sig"
//! \~russian Разрывает все соединения от события "sig" объекта "src"
//! \~english Disconnects source object "src" from all connections of event "sig".
//! \~russian Разрывает все соединения объекта-источника "src" от события "sig".
static void piDisconnect(PIObject * src, const PIString & sig);
// / Raise events
//! \~english Internal event delivery helper for registered events without arguments.
//! \~russian Внутренний помощник доставки для зарегистрированных событий без аргументов.
static void raiseEvent(PIObject * sender, const uint eventID) {
for (int j = 0; j < sender->connections.size_s(); ++j) {
Connection i(sender->connections[j]);
@@ -357,6 +478,8 @@ public:
}
}
//! \~english Internal event delivery helper for registered events with one argument.
//! \~russian Внутренний помощник доставки для зарегистрированных событий с одним аргументом.
template<typename T0>
static void raiseEvent(PIObject * sender, const uint eventID, const T0 & v0 = T0()) {
for (int j = 0; j < sender->connections.size_s(); ++j) {
@@ -390,6 +513,8 @@ public:
if (!sender->isPIObject()) break;
}
}
//! \~english Internal event delivery helper for registered events with two arguments.
//! \~russian Внутренний помощник доставки для зарегистрированных событий с двумя аргументами.
template<typename T0, typename T1>
static void raiseEvent(PIObject * sender, const uint eventID, const T0 & v0 = T0(), const T1 & v1 = T1()) {
for (int j = 0; j < sender->connections.size_s(); ++j) {
@@ -425,6 +550,8 @@ public:
if (!sender->isPIObject()) break;
}
}
//! \~english Internal event delivery helper for registered events with three arguments.
//! \~russian Внутренний помощник доставки для зарегистрированных событий с тремя аргументами.
template<typename T0, typename T1, typename T2>
static void raiseEvent(PIObject * sender, const uint eventID, const T0 & v0 = T0(), const T1 & v1 = T1(), const T2 & v2 = T2()) {
for (int j = 0; j < sender->connections.size_s(); ++j) {
@@ -462,6 +589,8 @@ public:
if (!sender->isPIObject()) break;
}
}
//! \~english Internal event delivery helper for registered events with four arguments.
//! \~russian Внутренний помощник доставки для зарегистрированных событий с четырьмя аргументами.
template<typename T0, typename T1, typename T2, typename T3>
static void raiseEvent(PIObject * sender,
const uint eventID,
@@ -507,7 +636,8 @@ public:
}
}
//! Returns PIObject* with name "name" or 0, if there is no object found
//! \~english Returns the first live object with name "name", or \c nullptr.
//! \~russian Возвращает первый живой объект с именем "name", либо \c nullptr.
static PIObject * findByName(const PIString & name) {
PIMutexLocker _ml(mutexObjects());
for (auto * i: PIObject::objects()) {
@@ -517,12 +647,12 @@ public:
return nullptr;
}
//! \~english Returns if this is valid %PIObject (check signature)
//! \~russian Возвращает действительный ли это %PIObject (проверяет подпись)
//! \~english Returns whether this pointer still refers to a live %PIObject instance.
//! \~russian Возвращает, указывает ли этот указатель на ещё существующий экземпляр %PIObject.
bool isPIObject() const { return isPIObject(this); }
//! \~english Returns if this is valid %PIObject subclass "T" (check signature and classname)
//! \~russian Возвращает действительный ли это наследник %PIObject типа "T" (проверяет подпись и имя класса)
//! \~english Returns whether this object belongs to class "T" or one of its registered descendants.
//! \~russian Возвращает, принадлежит ли этот объект классу "T" или одному из его зарегистрированных потомков.
template<typename T>
bool isTypeOf() const {
if (!isPIObject()) return false;
@@ -530,30 +660,35 @@ public:
return __meta_data()[classNameID()].scope_id.contains(T::__classNameIDS());
}
//! \~english Returns cast to T if this is valid subclass "T" (check by \a isTypeOf()) or "nullptr"
//! \~russian Возвращает преобразование к типу T если это действительный наследник типа "T" (проверяет через \a isTypeOf()), или
//! "nullptr"
//! \~english Returns this object cast to "T" when \a isTypeOf<T>() succeeds, otherwise \c nullptr.
//! \~russian Возвращает этот объект, приведённый к типу "T", если \a isTypeOf<T>() успешно, иначе \c nullptr.
template<typename T>
T * cast() const {
if (!isTypeOf<T>()) return (T *)nullptr;
return (T *)this;
}
//! \~english Returns if "o" is valid %PIObject (check signature)
//! \~russian Возвращает действительный ли "o" %PIObject (проверяет подпись)
//! \~english Returns whether "o" points to a live %PIObject instance.
//! \~russian Возвращает, указывает ли "o" на ещё существующий экземпляр %PIObject.
static bool isPIObject(const PIObject * o);
//! \~english Overload of \a isPIObject() for an untyped pointer.
//! \~russian Перегрузка \a isPIObject() для нетипизированного указателя.
static bool isPIObject(const void * o) { return isPIObject((PIObject *)o); }
//! \~english Returns if "o" is valid %PIObject subclass "T" (check signature and classname)
//! \~russian Возвращает действительный ли "o" наследник %PIObject типа "T" (проверяет подпись и имя класса)
//! \~english Returns whether "o" belongs to class "T" or one of its registered descendants.
//! \~russian Возвращает, принадлежит ли "o" классу "T" или одному из его зарегистрированных потомков.
template<typename T>
static bool isTypeOf(const PIObject * o) {
return o->isTypeOf<T>();
}
//! \~english Overload of \a isTypeOf() for an untyped pointer.
//! \~russian Перегрузка \a isTypeOf() для нетипизированного указателя.
template<typename T>
static bool isTypeOf(const void * o) {
return isTypeOf<T>((PIObject *)o);
}
//! \~english Simplifies a C++ type spelling for registered-method metadata.
//! \~russian Упрощает запись типа C++ для метаданных зарегистрированных методов.
static PIString simplifyType(const char * a, bool readable = true);
struct PIP_EXPORT __MetaFunc {
@@ -589,36 +724,32 @@ public:
};
typedef PIPair<const void *, __MetaFunc> __EHPair;
//! \~english Execute all posted events from CONNECTU_QUEUED connections
//! \~russian Выполнить все отложенные события от CONNECTU_QUEUED соединений
//! \~english Executes all queued deliveries posted to this performer object.
//! \~russian Выполняет все отложенные доставки, поставленные в очередь этому объекту-исполнителю.
void callQueuedEvents();
//! \~english
//! \brief Check if any CONNECTU_QUEUED connections to this object and execute them
//! \details This function is more optimized than \a callQueuedEvents() for objects that doesn`t
//! appears as \"performer\" target at CONNECTU_QUEUED
//! \~russian
//! \brief Если было хотя бы одно CONNECTU_QUEUED соединение с исполнителем this, то выполнить события
//! \details Этот метод более оптимален, чем \a callQueuedEvents(), для объектов, которые не были в роли
//! \"performer\" в макросе CONNECTU_QUEUED
//! \~\brief
//! \~english Executes queued deliveries only when this object was used as a performer.
//! \~russian Выполняет отложенные доставки только если этот объект использовался как исполнитель.
//! \~\details
//! \~english This helper is cheaper than unconditional \a callQueuedEvents() for objects that are rarely used as performer targets.
//! \~russian Этот помощник дешевле, чем безусловный \a callQueuedEvents(), для объектов, которые редко используются как исполнители.
bool maybeCallQueuedEvents() {
if (proc_event_queue) callQueuedEvents();
return proc_event_queue;
}
//! \~english Mark object to delete
//! \~russian Пометить объект на удаление
//! \~english Schedules the object for deferred deletion.
//! \~russian Планирует отложенное удаление объекта.
void deleteLater();
EVENT1(deleted, PIObject *, o);
//! \events
//! \{
//! \fn void deleted(PIObject * o)
//! \brief
//! \~english Raise before object delete
//! \~russian Вызывается перед удалением объекта
//! \~english Raised immediately before object destruction.
//! \~russian Вызывается непосредственно перед уничтожением объекта.
//! \~\warning
//! \~english
//! This event raised from destructor, so use only "o" numeric value,
@@ -626,19 +757,23 @@ public:
//! \~russian
//! Это событие вызывается из деструктора, поэтому используйте
//! только численное значение "o", не надо кастовать его в другие типы!
EVENT1(deleted, PIObject *, o);
//! \}
static PIMutex & __meta_mutex();
static PIMap<uint, __MetaData> & __meta_data(); // [hash(classname)]=__MetaData
static PIMap<uint, __MetaData> & __meta_data();
protected:
//! \~english Returns %PIObject* which has raised an event. This value is correct only in definition of some event handler
//! \~russian Возвращает %PIObject* который вызвал это событие. Значение допустимо только из методов обработчиков событий
//! \~english Returns the source object that raised the current event.
//! \~russian Возвращает объект-источник, который вызвал текущее событие.
//! \~\details
//! \~english This value is valid only while an event handler is running.
//! \~russian Это значение корректно только пока выполняется обработчик события.
PIObject * emitter() const { return emitter_; }
//! \~english Virtual function executes after property with name "name" has been changed
//! \~russian Виртуальная функция, вызывается после изменения любого свойства.
//! \~english Virtual method called after property "name" has been changed by \a setProperty().
//! \~russian Виртуальный метод, вызываемый после изменения свойства "name" через \a setProperty().
virtual void propertyChanged(const char * name) {}
private:
@@ -702,8 +837,15 @@ private:
};
#ifndef MICRO_PIP
//! \~english Dumps application-level %PIObject diagnostics.
//! \~russian Выводит диагностическую информацию уровня приложения для %PIObject.
PIP_EXPORT void dumpApplication(bool with_objects = true);
//! \~english Dumps application-level %PIObject diagnostics to file "path".
//! \~russian Выводит диагностическую информацию уровня приложения для %PIObject в файл "path".
PIP_EXPORT bool dumpApplicationToFile(const PIString & path, bool with_objects = true);
#endif
#endif // PIOBJECT_H

246
libs/main/core/piobject_macros.h
View File

@@ -1,9 +1,17 @@
/*! \file piobject_macros.h
* \ingroup Core
* \~\brief
* \~english PIObject macros
* \~russian Макросы PIObject
*/
//! \~\ingroup Core
//! \~\file piobject_macros.h
//! \~\brief
//! \~english PIObject macros for event system and object introspection
//! \~russian Макросы PIObject для событийной системы и интроспекции объектов
//! \~\details
//! \~english
//! This file declares the macro layer used by %PIObject-based classes:
//! class registration, event declaration, event handler declaration,
//! connection helpers and event raising helpers.
//! \~russian
//! Этот файл объявляет макросный слой для классов на базе %PIObject:
//! регистрацию класса, объявление событий, объявление обработчиков,
//! макросы соединения и макросы вызова событий.
/*
PIP - Platform Independent Primitives
Macros for PIObject
@@ -32,47 +40,47 @@
//! \relatesalso PIObject
//! \~\brief
//! \~english You should use this macro after class declaration to use EVENT and EVENT_HANDLER and correct piCoutObj output
//! \~russian Необходимо использовать этот макрос после объявления класса для использования событийной системы и корректного вывода
//! piCoutObj
//! \~english Put this macro inside a direct %PIObject subclass definition to enable registered events, event handlers and class metadata.
//! \~russian Поместите этот макрос внутрь объявления прямого наследника %PIObject, чтобы включить регистрацию событий, обработчиков и
//! метаданных класса.
# define PIOBJECT(name)
//! \relatesalso PIObject
//! \~\brief
//! \~english You should use this macro after class declaration to use EVENT and EVENT_HANDLER of parent class, and \a scopeList()
//! \~russian
//! \~english Put this macro inside a %PIObject subclass definition to inherit registered methods and class scope from "parent".
//! \~russian Поместите этот макрос внутрь объявления наследника %PIObject, чтобы унаследовать зарегистрированные методы и цепочку
//! классов от "parent".
# define PIOBJECT_SUBCLASS(name, parent)
//! \relatesalso PIObject
//! \~\brief
//! \~english Declare event handler with name \"name\" and return type \"ret\", ret name()
//! \~russian Объявляет обработчик событий с именем \"name\" и возвращаемым типом \"ret\", ret name()
//! \~english Declare a registered event handler method with signature `ret name()`.
//! \~russian Объявляет зарегистрированный метод-обработчик событий с сигнатурой `ret name()`.
# define EVENT_HANDLER0(ret, name) ret name()
//! \relatesalso PIObject
//! \~\brief
//! \~english Declare event handler with name \"name\" and return type \"ret\", ret name(type0 var0)
//! \~russian Объявляет обработчик событий с именем \"name\" и возвращаемым типом \"ret\", ret name(type0 var0)
//! \~english Declare a registered event handler method with one argument.
//! \~russian Объявляет зарегистрированный метод-обработчик событий с одним аргументом.
# define EVENT_HANDLER1(ret, name, type0, var0) ret name(type0 var0)
//! \relatesalso PIObject
//! \~\brief
//! \~english Declare event handler with name \"name\" and return type \"ret\", ret name(type0 var0, type1 var1)
//! \~russian Объявляет обработчик событий с именем \"name\" и возвращаемым типом \"ret\", ret name(type0 var0, type1 var1)
//! \~english Declare a registered event handler method with two arguments.
//! \~russian Объявляет зарегистрированный метод-обработчик событий с двумя аргументами.
# define EVENT_HANDLER2(ret, name, type0, var0, type1, var1) ret name(type0 var0, type1 var1)
//! \relatesalso PIObject
//! \~\brief
//! \~english Declare event handler with name \"name\" and return type \"ret\", ret name(type0 var0, type1 var1, type2 var2)
//! \~russian Объявляет обработчик событий с именем \"name\" и возвращаемым типом \"ret\", ret name(type0 var0, type1 var1, type2 var2)
//! \~english Declare a registered event handler method with three arguments.
//! \~russian Объявляет зарегистрированный метод-обработчик событий с тремя аргументами.
# define EVENT_HANDLER3(ret, name, type0, var0, type1, var1, type2, var2) ret name(type0 var0, type1 var1, type2 var2)
//! \relatesalso PIObject
//! \~\brief
//! \~english Declare event handler with name \"name\" and return type \"ret\", ret name(type0 var0, type1 var1, type2 var2, type3 var3)
//! \~russian Объявляет обработчик событий с именем \"name\" и возвращаемым типом \"ret\", ret name(type0 var0, type1 var1, type2 var2,
//! type3 var3)
//! \~english Declare a registered event handler method with four arguments.
//! \~russian Объявляет зарегистрированный метод-обработчик событий с четырьмя аргументами.
# define EVENT_HANDLER4(ret, name, type0, var0, type1, var1, type2, var2, type3, var3) \
ret name(type0 var0, type1 var1, type2 var2, type3 var3)
@@ -85,36 +93,32 @@
//! \relatesalso PIObject
//! \~\brief
//! \~english Declare virtual event handler with name \"name\" and return type \"ret\", virtual ret name()
//! \~russian Объявляет виртуальный обработчик событий с именем \"name\" и возвращаемым типом \"ret\", virtual ret name()
//! \~english Declare a virtual registered event handler method with signature `virtual ret name()`.
//! \~russian Объявляет виртуальный зарегистрированный метод-обработчик с сигнатурой `virtual ret name()`.
# define EVENT_VHANDLER0(ret, name) virtual ret name()
//! \relatesalso PIObject
//! \~\brief
//! \~english Declare virtual event handler with name \"name\" and return type \"ret\", virtual ret name(type0 var0)
//! \~russian Объявляет виртуальный обработчик событий с именем \"name\" и возвращаемым типом \"ret\", virtual ret name(type0 var0)
//! \~english Declare a virtual registered event handler method with one argument.
//! \~russian Объявляет виртуальный зарегистрированный метод-обработчик с одним аргументом.
# define EVENT_VHANDLER1(ret, name, type0, var0) virtual ret name(type0 var0)
//! \relatesalso PIObject
//! \~\brief
//! \~english Declare virtual event handler with name \"name\" and return type \"ret\", virtual ret name(type0 var0, type1 var1)
//! \~russian Объявляет виртуальный обработчик событий с именем \"name\" и возвращаемым типом \"ret\", virtual ret name(type0 var0, type1
//! var1)
//! \~english Declare a virtual registered event handler method with two arguments.
//! \~russian Объявляет виртуальный зарегистрированный метод-обработчик с двумя аргументами.
# define EVENT_VHANDLER2(ret, name, type0, var0, type1, var1) virtual ret name(type0 var0, type1 var1)
//! \relatesalso PIObject
//! \~\brief
//! \~english Declare virtual event handler with name \"name\" and return type \"ret\", virtual ret name(type0 var0, type1 var1, type2 var2)
//! \~russian Объявляет виртуальный обработчик событий с именем \"name\" и возвращаемым типом \"ret\", virtual ret name(type0 var0, type1
//! var1, type2 var2)
//! \~english Declare a virtual registered event handler method with three arguments.
//! \~russian Объявляет виртуальный зарегистрированный метод-обработчик с тремя аргументами.
# define EVENT_VHANDLER3(ret, name, type0, var0, type1, var1, type2, var2) virtual ret name(type0 var0, type1 var1, type2 var2)
//! \relatesalso PIObject
//! \~\brief
//! \~english Declare virtual event handler with name \"name\" and return type \"ret\", virtual ret name(type0 var0, type1 var1, type2 var2,
//! type3 var3)
//! \~russian Объявляет виртуальный обработчик событий с именем \"name\" и возвращаемым типом \"ret\", virtual ret name(type0 var0, type1
//! var1, type2 var2, type3 var3)
//! \~english Declare a virtual registered event handler method with four arguments.
//! \~russian Объявляет виртуальный зарегистрированный метод-обработчик с четырьмя аргументами.
# define EVENT_VHANDLER4(ret, name, type0, var0, type1, var1, type2, var2, type3, var3) \
virtual ret name(type0 var0, type1 var1, type2 var2, type3 var3)
@@ -127,32 +131,32 @@
//! \relatesalso PIObject
//! \~\brief
//! \~english Declare event with name \"name\", void name();
//! \~russian Объявляет событие с именем \"name\", void name();
//! \~english Declare an event method with no arguments.
//! \~russian Объявляет метод-событие без аргументов.
# define EVENT0(name) void name();
//! \relatesalso PIObject
//! \~\brief
//! \~english Declare event with name \"name\", void name(type0 var0);
//! \~russian Объявляет событие с именем \"name\", void name(type0 var0);
//! \~english Declare an event method with one argument.
//! \~russian Объявляет метод-событие с одним аргументом.
# define EVENT1(name, type0, var0) void name(type0 var0);
//! \relatesalso PIObject
//! \~\brief
//! \~english Declare event with name \"name\", void name(type0 var0, type1 var1);
//! \~russian Объявляет событие с именем \"name\", void name(type0 var0, type1 var1);
//! \~english Declare an event method with two arguments.
//! \~russian Объявляет метод-событие с двумя аргументами.
# define EVENT2(name, type0, var0, type1, var1) void name(type0 var0, type1 var1);
//! \relatesalso PIObject
//! \~\brief
//! \~english Declare event with name \"name\", void name(type0 var0, type1 var1, type2 var2);
//! \~russian Объявляет событие с именем \"name\", void name(type0 var0, type1 var1, type2 var2);
//! \~english Declare an event method with three arguments.
//! \~russian Объявляет метод-событие с тремя аргументами.
# define EVENT3(name, type0, var0, type1, var1, type2, var2) void name(type0 var0, type1 var1, type2 var2);
//! \relatesalso PIObject
//! \~\brief
//! \~english Declare event with name \"name\", void name(type0 var0, type1 var1, type2 var2, type3 var3);
//! \~russian Объявляет событие с именем \"name\", void name(type0 var0, type1 var1, type2 var2, type3 var3);
//! \~english Declare an event method with four arguments.
//! \~russian Объявляет метод-событие с четырьмя аргументами.
# define EVENT4(name, type0, var0, type1, var1, type2, var2, type3, var3) void name(type0 var0, type1 var1, type2 var2, type3 var3);
//! \relatesalso PIObject
@@ -162,10 +166,26 @@
# define EVENT EVENT0
//! \relatesalso PIObject
//! \~\brief
//! \~english Compatibility helper that raises event "event" on source object "src".
//! \~russian Совместимый вспомогательный макрос, вызывающий событие "event" у объекта-источника "src".
# define RAISE_EVENT0(src, event)
//! \relatesalso PIObject
//! \~english Compatibility helper that raises event "event" with one argument.
//! \~russian Совместимый вспомогательный макрос, вызывающий событие "event" с одним аргументом.
# define RAISE_EVENT1(src, event, v0)
//! \relatesalso PIObject
//! \~english Compatibility helper that raises event "event" with two arguments.
//! \~russian Совместимый вспомогательный макрос, вызывающий событие "event" с двумя аргументами.
# define RAISE_EVENT2(src, event, v0, v1)
//! \relatesalso PIObject
//! \~english Compatibility helper that raises event "event" with three arguments.
//! \~russian Совместимый вспомогательный макрос, вызывающий событие "event" с тремя аргументами.
# define RAISE_EVENT3(src, event, v0, v1, v2)
//! \relatesalso PIObject
//! \~english Compatibility helper that raises event "event" with four arguments.
//! \~russian Совместимый вспомогательный макрос, вызывающий событие "event" с четырьмя аргументами.
# define RAISE_EVENT4(src, event, v0, v1, v2, v3)
# define RAISE_EVENT RAISE_EVENT0
@@ -176,11 +196,11 @@
//! \~russian Соединяет событие \"event\" объекта \"src\" к обработчику или событию \"handler\" объекта \"dest\".
//! \~\details
//! \~english
//! \"handler\" can handle subset arguments of \"event\".
//! Returns \a PIObject::Connection
//! \"handler\" can accept a prefix of \"event\" arguments.
//! This macro resolves registered methods by name at run time and returns \a PIObject::Connection.
//! \~russian
//! \"handler\" может принимать не все аргументы от \"event\".
//! Возвращает \a PIObject::Connection
//! \"handler\" может принимать только начальную часть аргументов \"event\".
//! Макрос ищет зарегистрированные методы по имени во время выполнения и возвращает \a PIObject::Connection.
# define CONNECTU(src, event, dest, handler)
//! \relatesalso PIObject
@@ -189,17 +209,19 @@
//! \~russian Соединяет событие \"event\" объекта \"src\" к обработчику или событию \"handler\" объекта \"dest\".
//! \~\details
//! \~english
//! \"handler\" can handle subset arguments of \"event\".
//! Event handler will be executed by \"performer\" when \a PIObject::callQueuedEvents() called.
//! \"handler\" can accept a prefix of \"event\" arguments.
//! Delivery is queued on the performer object and runs only when that object calls
//! \a PIObject::callQueuedEvents() or \a PIObject::maybeCallQueuedEvents().
//! All argument types should be registered by \a REGISTER_VARIANT() macro, but many
//! common and PIP types already done.
//! Returns \a PIObject::Connection
//! Returns \a PIObject::Connection.
//! \~russian
//! \"handler\" может принимать не все аргументы от \"event\".
//! Обработчик будет вызван объектом \"performer\" при вызове \a PIObject::callQueuedEvents().
//! \"handler\" может принимать только начальную часть аргументов \"event\".
//! Доставка ставится в очередь объекта \"performer\" и выполняется только когда этот объект
//! вызывает \a PIObject::callQueuedEvents() или \a PIObject::maybeCallQueuedEvents().
//! Все типы аргументов должны быть зарегистрированы с помощью макроса \a REGISTER_VARIANT(),
//! однако многие стандартные и PIP типы уже там.
//! Возвращает \a PIObject::Connection
//! Возвращает \a PIObject::Connection.
# define CONNECTU_QUEUED(src, event, dest, handler, performer)
//! \relatesalso PIObject
@@ -208,13 +230,13 @@
//! \~russian Соединяет событие \"event\" объекта \"src\" к лямбда-функции \"functor\".
//! \~\details
//! \~english
//! \"event\" and \"functor\" must has equal argument lists.
//! You should parentness \"functor\" with () if this is complex lambda.
//! Returns \a PIObject::Connection
//! \"event\" and \"functor\" must have the same argument list.
//! Wrap \"functor\" in () when the lambda expression is complex.
//! Returns \a PIObject::Connection.
//! \~russian
//! \"event\" и \"functor\" должны иметь одинаковые аргументы.
//! В случае сложной лямбда-функции оберните её ().
//! Возвращает \a PIObject::Connection
//! \"event\" и \"functor\" должны иметь одинаковый список аргументов.
//! В случае сложной лямбда-функции оберните её в ().
//! Возвращает \a PIObject::Connection.
# define CONNECTL(src, event, functor)
//! \relatesalso PIObject
@@ -222,12 +244,11 @@
//! \~english Use \a CONNECTU() instead
//! \~russian Используйте \a CONNECTU()
//! \~\brief
//! \~english Connect event \"event\" from object \"src\" to event handler \"handler\" with return type \"ret\" from object \"dest\" with
//! check of event and handler exists
//! \~russian Соединяет событие \"event\" объекта \"src\" к обработчику или событию \"handler\" с возвращаемым типом \"ret\" объекта
//! \"dest\" с проверкой наличия события и обработчика.
//! \~english Legacy compatibility helper that connects an event to a registered handler with compile-time signature spelling.
//! \~russian Устаревший совместимый макрос, который соединяет событие с зарегистрированным обработчиком через явное указание сигнатуры.
//! \~\details
//! Returns PIObject::Connection
//! \~english Prefer \a CONNECTU() for new code.
//! \~russian Для нового кода предпочитайте \a CONNECTU().
# define CONNECT0(ret, src, event, dest, handler)
//! \relatesalso PIObject
@@ -235,12 +256,8 @@
//! \~english Use \a CONNECTU() instead
//! \~russian Используйте \a CONNECTU()
//! \~\brief
//! \~english Connect event \"event\" from object \"src\" to event handler \"handler\" with return type \"ret\" from object \"dest\" with
//! check of event and handler exists
//! \~russian Соединяет событие \"event\" объекта \"src\" к обработчику или событию \"handler\" с возвращаемым типом \"ret\" объекта
//! \"dest\" с проверкой наличия события и обработчика.
//! \~\details
//! Returns PIObject::Connection
//! \~english Legacy compatibility helper for a one-argument registered event or handler.
//! \~russian Устаревший совместимый макрос для зарегистрированного события или обработчика с одним аргументом.
# define CONNECT1(ret, type0, src, event, dest, handler)
//! \relatesalso PIObject
@@ -248,12 +265,8 @@
//! \~english Use \a CONNECTU() instead
//! \~russian Используйте \a CONNECTU()
//! \~\brief
//! \~english Connect event \"event\" from object \"src\" to event handler \"handler\" with return type \"ret\" from object \"dest\" with
//! check of event and handler exists
//! \~russian Соединяет событие \"event\" объекта \"src\" к обработчику или событию \"handler\" с возвращаемым типом \"ret\" объекта
//! \"dest\" с проверкой наличия события и обработчика.
//! \~\details
//! Returns PIObject::Connection
//! \~english Legacy compatibility helper for a two-argument registered event or handler.
//! \~russian Устаревший совместимый макрос для зарегистрированного события или обработчика с двумя аргументами.
# define CONNECT2(ret, type0, type1, src, event, dest, handler)
//! \relatesalso PIObject
@@ -261,12 +274,8 @@
//! \~english Use \a CONNECTU() instead
//! \~russian Используйте \a CONNECTU()
//! \~\brief
//! \~english Connect event \"event\" from object \"src\" to event handler \"handler\" with return type \"ret\" from object \"dest\" with
//! check of event and handler exists
//! \~russian Соединяет событие \"event\" объекта \"src\" к обработчику или событию \"handler\" с возвращаемым типом \"ret\" объекта
//! \"dest\" с проверкой наличия события и обработчика.
//! \~\details
//! Returns PIObject::Connection
//! \~english Legacy compatibility helper for a three-argument registered event or handler.
//! \~russian Устаревший совместимый макрос для зарегистрированного события или обработчика с тремя аргументами.
# define CONNECT3(ret, type0, type1, type2, src, event, dest, handler)
//! \relatesalso PIObject
@@ -274,12 +283,8 @@
//! \~english Use \a CONNECTU() instead
//! \~russian Используйте \a CONNECTU()
//! \~\brief
//! \~english Connect event \"event\" from object \"src\" to event handler \"handler\" with return type \"ret\" from object \"dest\" with
//! check of event and handler exists.
//! \~russian Соединяет событие \"event\" объекта \"src\" к обработчику или событию \"handler\" с возвращаемым типом \"ret\" объекта
//! \"dest\" с проверкой наличия события и обработчика.
//! \~\details
//! Returns PIObject::Connection
//! \~english Legacy compatibility helper for a four-argument registered event or handler.
//! \~russian Устаревший совместимый макрос для зарегистрированного события или обработчика с четырьмя аргументами.
# define CONNECT4(ret, type0, type1, type2, type3, src, event, dest, handler)
//! \relatesalso PIObject
@@ -297,10 +302,8 @@
//! \~english Use \a CONNECTU() instead
//! \~russian Используйте \a CONNECTU()
//! \~\brief
//! \~english Connect event \"event\" from object \"src\" to event handler \"handler\" with return type \"ret\" from object \"dest\" without
//! check of event exists
//! \~russian Соединяет событие \"event\" объекта \"src\" к обработчику или событию \"handler\" с возвращаемым типом \"ret\" объекта
//! \"dest\" без проверки наличия события и обработчика.
//! \~english Legacy compatibility helper that skips source method verification.
//! \~russian Устаревший совместимый макрос, который пропускает проверку исходного метода.
# define WEAK_CONNECT0(ret, src, event, dest, handler)
//! \relatesalso PIObject
@@ -308,10 +311,8 @@
//! \~english Use \a CONNECTU() instead
//! \~russian Используйте \a CONNECTU()
//! \~\brief
//! \~english Connect event \"event\" from object \"src\" to event handler \"handler\" with return type \"ret\" from object \"dest\" without
//! check of event exists
//! \~russian Соединяет событие \"event\" объекта \"src\" к обработчику или событию \"handler\" с возвращаемым типом \"ret\" объекта
//! \"dest\" без проверки наличия события и обработчика.
//! \~english Legacy compatibility helper that skips source method verification for one argument.
//! \~russian Устаревший совместимый макрос, который пропускает проверку исходного метода для случая с одним аргументом.
# define WEAK_CONNECT1(ret, type0, src, event, dest, handler)
//! \relatesalso PIObject
@@ -319,10 +320,8 @@
//! \~english Use \a CONNECTU() instead
//! \~russian Используйте \a CONNECTU()
//! \~\brief
//! \~english Connect event \"event\" from object \"src\" to event handler \"handler\" with return type \"ret\" from object \"dest\" without
//! check of event exists
//! \~russian Соединяет событие \"event\" объекта \"src\" к обработчику или событию \"handler\" с возвращаемым типом \"ret\" объекта
//! \"dest\" без проверки наличия события и обработчика.
//! \~english Legacy compatibility helper that skips source method verification for two arguments.
//! \~russian Устаревший совместимый макрос, который пропускает проверку исходного метода для случая с двумя аргументами.
# define WEAK_CONNECT2(ret, type0, type1, src, event, dest, handler)
//! \relatesalso PIObject
@@ -330,10 +329,8 @@
//! \~english Use \a CONNECTU() instead
//! \~russian Используйте \a CONNECTU()
//! \~\brief
//! \~english Connect event \"event\" from object \"src\" to event handler \"handler\" with return type \"ret\" from object \"dest\" without
//! check of event exists
//! \~russian Соединяет событие \"event\" объекта \"src\" к обработчику или событию \"handler\" с возвращаемым типом \"ret\" объекта
//! \"dest\" без проверки наличия события и обработчика.
//! \~english Legacy compatibility helper that skips source method verification for three arguments.
//! \~russian Устаревший совместимый макрос, который пропускает проверку исходного метода для случая с тремя аргументами.
# define WEAK_CONNECT3(ret, type0, type1, type2, src, event, dest, handler)
//! \relatesalso PIObject
@@ -341,10 +338,8 @@
//! \~english Use \a CONNECTU() instead
//! \~russian Используйте \a CONNECTU()
//! \~\brief
//! \~english Connect event \"event\" from object \"src\" to event handler \"handler\" with return type \"ret\" from object \"dest\" without
//! check of event exists
//! \~russian Соединяет событие \"event\" объекта \"src\" к обработчику или событию \"handler\" с возвращаемым типом \"ret\" объекта
//! \"dest\" без проверки наличия события и обработчика.
//! \~english Legacy compatibility helper that skips source method verification for four arguments.
//! \~russian Устаревший совместимый макрос, который пропускает проверку исходного метода для случая с четырьмя аргументами.
# define WEAK_CONNECT4(ret, type0, type1, type2, type3, src, event, dest, handler)
//! \relatesalso PIObject
@@ -359,37 +354,32 @@
//! \relatesalso PIObject
//! \~\brief
//! \~english piDisconnect event \"event\" from object \"src\" from event handler \"handler\" with return type \"ret\" from object \"dest\"
//! \~russian piDisconnect событие \"event\" объекта \"src\" от обработчика или события \"handler\" с возвращаемым типом \"ret\" объекта
//! \"dest\"
//! \~english Disconnect a registered event from a registered event handler.
//! \~russian Разрывает соединение зарегистрированного события с зарегистрированным обработчиком.
# define DISCONNECT0(ret, src, event, dest, handler)
//! \relatesalso PIObject
//! \~\brief
//! \~english piDisconnect event \"event\" from object \"src\" from event handler \"handler\" with return type \"ret\" from object \"dest\"
//! \~russian piDisconnect событие \"event\" объекта \"src\" от обработчика или события \"handler\" с возвращаемым типом \"ret\" объекта
//! \"dest\"
//! \~english Disconnect a one-argument registered event from a registered event handler.
//! \~russian Разрывает соединение зарегистрированного события с одним аргументом и зарегистрированного обработчика.
# define DISCONNECT1(ret, type0, src, event, dest, handler)
//! \relatesalso PIObject
//! \~\brief
//! \~english piDisconnect event \"event\" from object \"src\" from event handler \"handler\" with return type \"ret\" from object \"dest\"
//! \~russian piDisconnect событие \"event\" объекта \"src\" от обработчика или события \"handler\" с возвращаемым типом \"ret\" объекта
//! \"dest\"
//! \~english Disconnect a two-argument registered event from a registered event handler.
//! \~russian Разрывает соединение зарегистрированного события с двумя аргументами и зарегистрированного обработчика.
# define DISCONNECT2(ret, type0, type1, src, event, dest, handler)
//! \relatesalso PIObject
//! \~\brief
//! \~english piDisconnect event \"event\" from object \"src\" from event handler \"handler\" with return type \"ret\" from object \"dest\"
//! \~russian piDisconnect событие \"event\" объекта \"src\" от обработчика или события \"handler\" с возвращаемым типом \"ret\" объекта
//! \"dest\"
//! \~english Disconnect a three-argument registered event from a registered event handler.
//! \~russian Разрывает соединение зарегистрированного события с тремя аргументами и зарегистрированного обработчика.
# define DISCONNECT3(ret, type0, type1, type2, src, event, dest, handler)
//! \relatesalso PIObject
//! \~\brief
//! \~english piDisconnect event \"event\" from object \"src\" from event handler \"handler\" with return type \"ret\" from object \"dest\"
//! \~russian piDisconnect событие \"event\" объекта \"src\" от обработчика или события \"handler\" с возвращаемым типом \"ret\" объекта
//! \"dest\"
//! \~english Disconnect a four-argument registered event from a registered event handler.
//! \~russian Разрывает соединение зарегистрированного события с четырьмя аргументами и зарегистрированного обработчика.
# define DISCONNECT4(ret, type0, type1, type2, type3, src, event, dest, handler)
//! \relatesalso PIObject
@@ -401,8 +391,8 @@
//! \relatesalso PIObject
//! \~\brief
//! \~english Returns pointer to events handler \"handler\"
//! \~russian Возвращает указатель на обработчик события \"handler\"
//! \~english Low-level helper that expands to the registered handler entry point.
//! \~russian Низкоуровневый вспомогательный макрос, который разворачивается в точку входа зарегистрированного обработчика.
# define HANDLER(handler)