PIMap {{K, T}, {K, T}, ...} constructor

doc ru

libs/main/containers/pimap.h

@@ -78,6 +78,10 @@ public:
 	PIMap() {;}
 	PIMap(const PIMap<Key, T> & other) {*this = other;}
 	PIMap(PIMap<Key, T> && other) : pim_content(std::move(other.pim_content)), pim_index(std::move(other.pim_index)) {}
+	PIMap(std::initializer_list<std::tuple<Key, T>> init_list) {
+		for (auto i: init_list)
+			insert(std::get<0>(i), std::get<1>(i));
+	}
 	virtual ~PIMap() {;}
 
 	PIMap<Key, T> & operator =(const PIMap<Key, T> & other) {

libs/main/io_devices/piiodevice.cpp

@@ -23,13 +23,7 @@
 #include "pipropertystorage.h"
 
 
-//! \addtogroup IO
-//! \{
 //! \class PIIODevice piiodevice.h
-//! \brief
-//! \~english Base class for input/output classes
-//! \~russian Базовый класс утройств ввода/вывода
-//!
 //! \~\details
 //! \section PIIODevice_sec0 Synopsis
 //! This class provide open/close logic, threaded read/write and virtual input/output
@@ -116,7 +110,6 @@
 //! \section PIIODevice_ex0 Example
 //! \snippet piiodevice.cpp 0
 //!
-//! \}
 
 
 PIMutex PIIODevice::nfp_mutex;
@@ -130,9 +123,6 @@ PIIODevice::PIIODevice(): PIThread() {
 }
 
 
-/*! \brief Constructs a PIIODevice with path and mode
- * \param path path to device
- * \param type mode for open */
 PIIODevice::PIIODevice(const PIString & path, PIIODevice::DeviceMode mode): PIThread() {
 	mode_ = mode;
 	_init();
@@ -159,6 +149,34 @@ bool PIIODevice::setOption(PIIODevice::DeviceOption o, bool yes) {
 }
 
 
+//! \~\details
+//! \~english
+//! Set external static function of threaded read that will be executed
+//! at every successful threaded read. Function should have format
+//! "bool func(void * data, uchar * readed, int size)"
+//! \~russian
+//! Устанавливает внешний статический метод, который будет вызван
+//! после каждого успешного потокового чтения. Метод должен быть
+//! в формате "bool func(void * data, uchar * readed, int size)"
+void PIIODevice::setThreadedReadSlot(ReadRetFunc func) {
+	ret_func_ = func;
+}
+
+
+//! \~\details
+//! \~english
+//! Default size is 4096 bytes. If your device can read at single read
+//! more than 4096 bytes you should use this function to adjust buffer size
+//! \~russian
+//! По умолчанию 4096 байт. Если устройство за одно чтение может читать
+//! более 4096 байт, необходимо использовать этот метод для установки
+//! нужного размера буфера
+void PIIODevice::setThreadedReadBufferSize(int new_size) {
+	threaded_read_buffer_size = new_size;
+	threadedReadBufferSizeChanged();
+}
+
+
 bool stopThread(PIThread * t, bool hard) {
 #ifdef MICRO_PIP
 	t->stop(true);
@@ -524,6 +542,13 @@ PIString PIIODevice::fullPathOptions() const {
 }
 
 
+//! \~\details
+//! \~english
+//! To function \a configureFromFullPath() "full_path" passed without \a fullPathPrefix() and "://".
+//! See \ref PIIODevice_sec7
+//! \~russian
+//! В метод \a configureFromFullPath() "full_path" передается без \a fullPathPrefix() и "://".
+//! См. \ref PIIODevice_sec7
 PIIODevice * PIIODevice::createFromFullPath(const PIString & full_path) {
 	PIString prefix = full_path.left(full_path.find(":"));
 	PIIODevice * nd = newDeviceByPrefix(prefix.dataAscii());

libs/main/io_devices/piiodevice.h

@@ -37,10 +37,22 @@ typedef bool (*ReadRetFunc)(void * , uchar * , int );
 
 #ifdef DOXYGEN
 
-//! \relatesalso PIIODevice \brief Use this macro to enable automatic creation instances of your class with \a createFromFullPath() function
+//! \relatesalso PIIODevice
+//! \brief
+//! \~english Enable device instances creation with \a PIIODevice::createFromFullPath() function.
+//! \~russian Включить создание экземпляров устройства с помощью метода \a PIIODevice::createFromFullPath().
+//! \~\details
+//! \~english This macro may be placed in cpp or header file, but preferred place is header
+//! \~russian Этот макрос может быть расположен в cpp или заголовочном файле, но предпочтительнее распологать в заголовочном
 #  define REGISTER_DEVICE(class)
 
-//! \relatesalso PIIODevice \brief Use this macro instead of PIOBJECT when describe your own PIIODevice
+//! \relatesalso PIIODevice
+//! \brief
+//! \~english Use this macro instead of PIOBJECT when describe your own PIIODevice.
+//! \~russian Используйте этот макрос вместо PIOBJECT при объявлении своего PIIODevice.
+//! \~\param "prefix"
+//! \~english Unique device prefix in quotes, may be ""
+//! \~russian Уникальный префикс устройства в кавычках, может быть ""
 #  define PIIODEVICE(class, "prefix")
 
 #else
@@ -61,6 +73,10 @@ typedef bool (*ReadRetFunc)(void * , uchar * , int );
 
 #endif
 
+//! \ingroup IO
+//! \~\brief
+//! \~english Base class for input/output devices.
+//! \~russian Базовый класс утройств ввода/вывода.
 class PIP_EXPORT PIIODevice: public PIThread
 {
 	PIOBJECT_SUBCLASS(PIIODevice, PIThread)
@@ -68,26 +84,30 @@ class PIP_EXPORT PIIODevice: public PIThread
 public:
 	NO_COPY_CLASS(PIIODevice)
 	
-	//! Constructs a empty PIIODevice
+	//! \~english Constructs a empty %PIIODevice
+	//! \~russian Создает пустой %PIIODevice
 	explicit PIIODevice();
 
-	//! \brief Open modes for PIIODevice
+	//! \~english Open modes for PIIODevice
+	//! \~russian Режимы открытия для PIIODevice
 	enum DeviceMode {
-		ReadOnly /*! Device can only read */ = 0x01,
+		ReadOnly  /*! \~english Device can only read \~russian Устройство может только читать */ = 0x01,
-		WriteOnly /*! Device can only write */ = 0x02,
+		WriteOnly /*! \~english Device can only write \~russian Устройство может только писать */ = 0x02,
-		ReadWrite /*! Device can both read and write */ = 0x03
+		ReadWrite /*! \~english Device can both read and write \~russian Устройство может читать и писать */ = 0x03
 	};
 
-	//! \brief Options for PIIODevice, works with some devices
+	//! \~english Options for PIIODevice, works with some devices
+	//! \~russian Опции для PIIODevice, работает для некоторых устройств
 	enum DeviceOption {
-		BlockingRead /*! \a read block until data is received, default off */ = 0x01,
+		BlockingRead  /*! \~english \a read() block until data is received, default off \~russian \a read() блокируется, пока данные не поступят, по умолчанию выключено */ = 0x01,
-		BlockingWrite /*! \a write block until data is sent, default off */ = 0x02
+		BlockingWrite /*! \~english \a write() block until data is sent, default off \~russian \a write() блокируется, пока данные не запишутся, по умолчанию выключено */ = 0x02
 	};
 
-	//! \brief Characteristics of PIIODevice subclass
+	//! \~english Characteristics of PIIODevice channel
+	//! \~russian Характеристики канала PIIODevice
 	enum DeviceInfoFlag {
-		Sequential /*! Continuous bytestream without datagrams */ = 0x01,
+		Sequential /*! \~english Continuous bytestream without packets \~russian Непрерывный поток байт, без пакетирования */ = 0x01,
-		Reliable /*! Channel without data errors / corruptions */ = 0x02
+		Reliable   /*! \~english Channel without data errors or corruptions \~russian Канал без ошибок или повреждений данных */ = 0x02
 	};
 
 	struct FabricInfo {
@@ -99,185 +119,232 @@ public:
 	typedef PIFlags<DeviceOption> DeviceOptions;
 	typedef PIFlags<DeviceInfoFlag> DeviceInfoFlags;
 
+	//! \~english Constructs %PIIODevice with path "path" and open mode "mode"
+	//! \~russian Создает %PIIODevice с путём "path" и режимом открытия "mode"
 	explicit PIIODevice(const PIString & path, DeviceMode mode = ReadWrite);
+
 	virtual ~PIIODevice();
 
-	//! Current open mode of device
+	//! \~english Returns current open mode of device
+	//! \~russian Возвращает текущий режим открытия устройства
 	DeviceMode mode() const {return mode_;}
 	
-	//! Set open mode of device
+	//! \~english Set open mode of device. Don`t reopen device
+	//! \~russian Устанавливает режим открытия устройства. Не переоткрывает устройство
 	void setMode(DeviceMode m) {mode_ = m;}
 
-	//! Current device options
+	//! \~english Returns current device options
+	//! \~russian Возвращает текущие опции устройства
 	DeviceOptions options() const {return options_;}
 
-	//! Current device option "o" state
+	//! \~english Returns current device option "o" state
+	//! \~russian Возвращает текущее состояние опции "o"
 	bool isOptionSet(DeviceOption o) const {return options_[o];}
 
-	//! Set device options
+	//! \~english Set device options
+	//! \~russian Устанавливает опции устройства
 	void setOptions(DeviceOptions o);
 
-	//! Set device option "o" to "yes" and return previous state
+	//! \~english Set device option "o" to "yes" and returns previous state
+	//! \~russian Устанавливает опцию "o" устройства в "yes" и возвращает предыдущее состояние опции
 	bool setOption(DeviceOption o, bool yes = true);
 
-	//! Returns device characteristic flags
+	//! \~english Returns device characteristic flags
+	//! \~russian Возвращает характеристики канала
 	DeviceInfoFlags infoFlags() const {return deviceInfoFlags();}
 
-	//! Current path of device
+	//! \~english Returns current path of device
+	//! \~russian Возвращает текущий путь устройства
 	PIString path() const {return property("path").toString();}
 	
-	//! Set path of device
+	//! \~english Set path of device. Don`t reopen device
+	//! \~russian Устанавливает путь устройства. Не переоткрывает устройство
 	void setPath(const PIString & path) {setProperty("path", path);}
 	
-	//! Return \b true if mode is ReadOnly or ReadWrite
+	//! \~english Returns if mode is ReadOnly or ReadWrite
+	//! \~russian Возвращает равен ли режим открытия ReadOnly или ReadWrite
 	bool isReadable() const {return (mode_ & ReadOnly);}
 	
-	//! Return \b true if mode is WriteOnly or ReadWrite
+	//! \~english Returns if mode is WriteOnly or ReadWrite
+	//! \~russian Возвращает равен ли режим открытия WriteOnly или ReadWrite
 	bool isWriteable() const {return (mode_ & WriteOnly);}
 	
-	//! Return \b true if device is successfully opened
+	//! \~english Returns if device is successfully opened
+	//! \~russian Возвращает успешно ли открыто устройство
 	bool isOpened() const {return opened_;}
 	
-	//! Return \b true if device is closed
+	//! \~english Returns if device is closed
+	//! \~russian Возвращает закрыто ли устройство
 	bool isClosed() const {return !opened_;}
 	
-	//! Return \b true if device can read \b now
+	//! \~english Returns if device can read \b now
+	//! \~russian Возвращает может ли устройство читать \b сейчас
 	virtual bool canRead() const {return opened_ && (mode_ & ReadOnly);}
 	
-	//! Return \b true if device can write \b now
+	//! \~english Returns if device can write \b now
+	//! \~russian Возвращает может ли устройство писать \b сейчас
 	virtual bool canWrite() const {return opened_ && (mode_ & WriteOnly);}
 
 
-	//! Set execution of \a open enabled while threaded read on closed device
+	//! \~english Set calling of \a open() enabled while threaded read on closed device
+	//! \~russian Устанавливает возможность вызова \a open() при потоковом чтении на закрытом устройстве
 	void setReopenEnabled(bool yes = true) {setProperty("reopenEnabled", yes);}
 	
-	//! Set timeout in milliseconds between \a open tryings if reopen is enabled
+	//!
+	//! \~english Set timeout in milliseconds between \a open() tryings if reopen is enabled
+	//! \~russian Устанавливает задержку в миллисекундах между вызовами \a open() если переоткрытие активно
 	void setReopenTimeout(int msecs) {setProperty("reopenTimeout", msecs);}
 
-	
+	//! \~english Returns reopen enable
-	//! Return reopen enable
+	//! \~russian Возвращает активно ли переоткрытие
 	bool isReopenEnabled() const {return property("reopenEnabled").toBool();}
 	
-	//! Return reopen timeout
+	//! \~english Returns reopen timeout in milliseconds
+	//! \~russian Возвращает задержку переоткрытия в миллисекундах
 	int reopenTimeout() {return property("reopenTimeout").toInt();}
 
 
-	/** \brief Set "threaded read slot"
+	//! \~english Set threaded read callback
-	 * \details Set external static function of threaded read that will be executed
+	//! \~russian Устанавливает callback потокового чтения
-	 * at every successful threaded read. Function should have format
+	void setThreadedReadSlot(ReadRetFunc func);
-	 * "bool func(void * data, uchar * readed, int size)" */
-	void setThreadedReadSlot(ReadRetFunc func) {ret_func_ = func;}
 	
-	//! Set custom data that will be passed to "threaded read slot"
+	//! \~english Set custom data that will be passed to threaded read callback
+	//! \~russian Устанавливает произвольный указатель, который будет передан в callback потокового чтения
 	void setThreadedReadData(void * d) {ret_data_ = d;}
 	
-	/** \brief Set size of threaded read buffer
+	//! \~english Set size of threaded read buffer
-	 * \details Default size is 4096 bytes. If your device can read at single read
+	//! \~russian Устанавливает размер буфера потокового чтения
-	 * more than 4096 bytes you should use this function to adjust buffer size */
+	void setThreadedReadBufferSize(int new_size);
-	void setThreadedReadBufferSize(int new_size) {threaded_read_buffer_size = new_size; threadedReadBufferSizeChanged();}
 
-	//! Return size of threaded read buffer
+	//! \~english Returns size of threaded read buffer
+	//! \~russian Возвращает размер буфера потокового чтения
 	int threadedReadBufferSize() const {return threaded_read_buffer_size;}
 	
-	//! Return content of threaded read buffer
+	//! \~english Returns content of threaded read buffer
+	//! \~russian Возвращает содержимое буфера потокового чтения
 	const uchar * threadedReadBuffer() const {return buffer_tr.data();}
 
-	//! Return custom data that will be passed to "threaded read slot"
+	//! \~english Returns custom data that will be passed to threaded read callback
+	//! \~russian Возвращает произвольный указатель, который будет передан в callback потокового чтения
 	void * threadedReadData() const {return ret_data_;}
 
 	
-	//! Return \b true if threaded read is started
+	//! \~english Returns if threaded read is started
+	//! \~russian Возвращает запущен ли поток чтения
 	bool isThreadedRead() const {return isRunning();}
 	
-	//! Start threaded read
+	//! \~english Start threaded read
+	//! \~russian Запускает потоковое чтение
 	void startThreadedRead() {if (!isRunning()) PIThread::start();}
 	
-	//! Start threaded read and assign "threaded read slot" to "func"
+	//! \~english Start threaded read and assign threaded read callback to "func"
+	//! \~russian Запускает потоковое чтение и устанавливает callback потокового чтения в "func"
 	void startThreadedRead(ReadRetFunc func) {ret_func_ = func; startThreadedRead();}
 	
-	//! Stop threaded read. Hard stop terminate thread, otherwise wait fo 10 seconds
+	//! \~english Stop threaded read. Hard stop terminate thread, otherwise wait fo 10 seconds
+	//! \~russian Останавливает потоковое чтение. Жесткая остановка убивает поток, иначе ожидает 10 секунд
 	void stopThreadedRead(bool hard = true);
 	
 	
-	//! Return \b true if threaded write is started
+	//! \~english Returns if threaded write is started
+	//! \~russian Возвращает запущен ли поток записи
 	bool isThreadedWrite() const {return write_thread.isRunning();}
 	
-	//! Start threaded write
+	//! \~english Start threaded write
+	//! \~russian Запускает потоковую запись
 	void startThreadedWrite() {if (!write_thread.isRunning()) write_thread.startOnce();}
 	
-	//! Stop threaded write. Hard stop terminate thread, otherwise wait fo 10 seconds
+	//! \~english Stop threaded write. Hard stop terminate thread, otherwise wait fo 10 seconds
+	//! \~russian Останавливает потоковую запись. Жесткая остановка убивает поток, иначе ожидает 10 секунд
 	void stopThreadedWrite(bool hard = true);
 	
-	//! Clear threaded write task queue
+	//! \~english Clear threaded write task queue
+	//! \~russian Очищает очередь потоковой записи
 	void clearThreadedWriteQueue();
 
 	
-	//! Start both threaded read and threaded write
+	//! \~english Start both threaded read and threaded write
+	//! \~russian Запускает потоковое чтение и запись
 	void start();
 	
-	//! Stop both threaded read and threaded write. Hard stop terminate threads, otherwise wait fo 10 seconds
+	//! \~english Stop both threaded read and threaded write. Hard stop terminate threads, otherwise wait fo 10 seconds
+	//! \~russian Останавливает потоковое чтение и запись. Жесткая остановка убивает потоки, иначе ожидает 10 секунд
 	void stop(bool hard = true);
 
 
-	//! Read from device maximum "max_size" bytes to "read_to"
+	//! \~english Read from device maximum "max_size" bytes to "read_to"
+	//! \~russian Читает из устройства не более "max_size" байт в "read_to"
 	int read(void * read_to, int max_size) {return readDevice(read_to, max_size);}
 
-	//! Read from device maximum "max_size" bytes and return them as PIByteArray
+	//! \~english Read from device maximum "max_size" bytes and returns them as PIByteArray
+	//! \~russian Читает из устройства не более "max_size" байт и возвращает данные как PIByteArray
 	PIByteArray read(int max_size);
 
-	//! Write maximum "max_size" bytes of "data" to device
+	//! \~english Write maximum "max_size" bytes of "data" to device
+	//! \~russian Пишет в устройство не более "max_size" байт из "data"
 	int write(const void * data, int max_size) {return writeDevice(data, max_size);}
 
-	//! Read from device for "timeout_ms" milliseconds and return readed data as PIByteArray. Timeout should to be greater than 0
+	//! \~english Read from device for "timeout_ms" milliseconds and return readed data as PIByteArray.
+	//! Timeout should to be greater than 0
+	//! \~russian Читает из устройства в течении "timeout_ms" миллисекунд и возвращает данные как PIByteArray.
+	//! Таймаут должен быть больше 0
 	PIByteArray readForTime(double timeout_ms);
 	
 
-	//! Add task to threaded write queue and return task ID
+	//! \~english Add task to threaded write queue and return task ID
+	//! \~russian Добавляет данные в очередь на потоковую запись и возвращает ID задания
 	ullong writeThreaded(const void * data, int max_size) {return writeThreaded(PIByteArray(data, uint(max_size)));}
 	
-	//! Add task to threaded write queue and return task ID
+	//! \~english Add task to threaded write queue and return task ID
+	//! \~russian Добавляет данные в очередь на потоковую запись и возвращает ID задания
 	ullong writeThreaded(const PIByteArray & data);
 	
 	
-	//! Configure device from section "section" of file "config_file", if "parent_section" parent section also will be read
+	//! \~english Configure device from section "section" of file "config_file", if "parent_section" parent section also will be read
+	//! \~russian
 	bool configure(const PIString & config_file, const PIString & section, bool parent_section = false);
 	
 	
-	//! Returns full unambiguous string prefix. \ref PIIODevice_sec7
+	//! \~english Returns full unambiguous string prefix. \ref PIIODevice_sec7
+	//! \~russian Возвращает префикс устройства. \ref PIIODevice_sec7
 	virtual PIConstChars fullPathPrefix() const {return "";}
 
 	static PIConstChars fullPathPrefixS() {return "";}
 	
-	//! Returns full unambiguous string, describes this device, \a fullPathPrefix() + "://"
+	//! \~english Returns full unambiguous string, describes this device, \a fullPathPrefix() + "://" + ...
+	//! \~russian Возвращает строку полного описания для этого устройства, \a fullPathPrefix() + "://" + ...
 	PIString constructFullPath() const;
 
-	//! Configure device with parameters of full unambiguous string
+	//! \~english Configure device with parameters of full unambiguous string
+	//! \~russian Настраивает устройство из параметров строки полного описания
 	void configureFromFullPath(const PIString & full_path);
 
-	//! Returns PIVariantTypes::IODevice, describes this device
+	//! \~english Returns PIVariantTypes::IODevice, describes this device
+	//! \~russian Возвращает PIVariantTypes::IODevice, описывающий это устройство
 	PIVariantTypes::IODevice constructVariant() const;
 
-	//! Configure device from PIVariantTypes::IODevice
+	//! \~english Configure device from PIVariantTypes::IODevice
+	//! \~russian Настраивает устройство из PIVariantTypes::IODevice
 	void configureFromVariant(const PIVariantTypes::IODevice & d);
 
-	//! \brief Try to determine suitable device, create new one, configure it with \a configureFromFullPath() and returns it.
+	//! \~english Try to create new device by prefix, configure it with \a configureFromFullPath() and returns it.
-	//! \details To function \a configureFromFullPath() "full_path" passed without \a fullPathPrefix() + "://".
+	//! \~russian Пытается создать новое устройство по префиксу, настраивает с помощью \a configureFromFullPath() и возвращает его
-	//! See \ref PIIODevice_sec7
 	static PIIODevice * createFromFullPath(const PIString & full_path);
 
-	//! \brief Try to determine suitable device, create new one, configure it with \a configureFromVariant() and returns it.
+	//! \~english Try to create new device by prefix, configure it with \a configureFromVariant() and returns it.
-	//! \details To function \a configureFromFullPath() "full_path" passed without \a fullPathPrefix() + "://".
+	//! \~russian Пытается создать новое устройство по префиксу, настраивает с помощью \a configureFromVariant() и возвращает его
-	//! See \ref PIIODevice_sec7
 	static PIIODevice * createFromVariant(const PIVariantTypes::IODevice & d);
 	
 	static PIString normalizeFullPath(const PIString & full_path);
 
 	static void splitFullPath(PIString fpwm, PIString * full_path, DeviceMode * mode = 0, DeviceOptions * opts = 0);
 
-	//! Returns fullPath prefixes of all registered devices
+	//! \~english Returns fullPath prefixes of all registered devices
+	//! \~russian Возвращает префиксы всех зарегистрированных устройств
 	static PIStringList availablePrefixes();
 
-	//! Returns class names of all registered devices
+	//! \~english Returns class names of all registered devices
+	//! \~russian Возвращает имена классов всех зарегистрированных устройств
 	static PIStringList availableClasses();
 
 	static void registerDevice(PIConstChars prefix, PIConstChars classname, PIIODevice*(*fabric)());
@@ -301,111 +368,149 @@ public:
 //! \{
 
 	//! \fn bool open()
-	//! \brief Open device
+	//! \~english Open device
-	
+	//! \~russian Открывает устройство
+
 	//! \fn bool open(const PIString & path)
-	//! \brief Open device with path "path"
+	//! \~english Open device with path "path"
+	//! \~russian Открывает устройство с путём "path"
 
 	//! \fn bool open(const DeviceMode & mode)
-	//! \brief Open device with mode "mode"
+	//! \~english Open device with mode "mode"
+	//! \~russian Открывает устройство с режимом открытия "mode"
 
 	//! \fn bool open(const PIString & path, const DeviceMode & mode)
-	//! \brief Open device with path "path" and mode "mode"
+	//! \~english Open device with path "path" and mode "mode"
+	//! \~russian Открывает устройство с путём "path" и режимом открытия "mode"
 
 	//! \fn bool close()
-	//! \brief Close device
+	//! \~english Close device
+	//! \~russian Закрывает устройство
 
 	//! \fn int write(PIByteArray data)
-	//! \brief Write "data" to device
+	//! \~english Write "data" to device
+	//! \~russian Пишет "data" в устройство
 
 //! \}
 //! \vhandlers
 //! \{
 
 	//! \fn void flush()
-	//! \brief Immediate write all buffers
+	//! \~english Immediate write all buffers
-	
+	//! \~russian Немедленно записать все буферизированные данные
+
 //! \}
 //! \events
 //! \{
 
 	//! \fn void opened()
-	//! \brief Raise if succesfull open
+	//! \~english Raise if succesfull open
-	
+	//! \~russian Вызывается при успешном открытии
+
 	//! \fn void closed()
-	//! \brief Raise if succesfull close
+	//! \~english Raise if succesfull close
+	//! \~russian Вызывается при успешном закрытии
 
 	//! \fn void threadedReadEvent(uchar * readed, int size)
-	//! \brief Raise if read thread succesfull read some data
+	//! \~english Raise if read thread succesfull read some data
+	//! \~russian Вызывается при успешном потоковом чтении данных
 
 	//! \fn void threadedWriteEvent(ullong id, int written_size)
-	//! \brief Raise if write thread successfull write some data of task with ID "id"
+	//! \~english Raise if write thread successfull write some data of task with ID "id"
-	
+	//! \~russian Вызывается при успешной потоковой записи данных с ID задания "id"
+
 //! \}
 //! \ioparams
 //! \{
 #ifdef DOXYGEN
-	//! \brief setReopenEnabled, default "true"
+	//! \~english setReopenEnabled, default "true"
+	//! \~russian setReopenEnabled, по умолчанию "true"
 	bool reopenEnabled;
 	
-	//! \brief setReopenTimeout in ms, default 1000
+	//! \~english setReopenTimeout in milliseconds, default 1000
+	//! \~russian setReopenTimeout в миллисекундах, по умолчанию 1000
 	int reopenTimeout;
 	
-	//! \brief setThreadedReadBufferSize in bytes, default 4096
+	//! \~english setThreadedReadBufferSize in bytes, default 4096
+	//! \~russian setThreadedReadBufferSize в байтах, по умолчанию 4096
 	int threadedReadBufferSize;
 #endif
 //! \}
 
 protected:
 	
-	//! Function executed before first \a openDevice() or from constructor
+	//! \~english Function executed before first \a openDevice() or from constructor
+	//! \~russian Метод вызывается перед первым \a openDevice() или из конструктора
 	virtual bool init() {return true;}
 	
-	//! Reimplement to configure device from entries "e_main" and "e_parent", cast arguments to \a PIConfig::Entry*
+	//! \~english Reimplement to configure device from entries "e_main" and "e_parent", cast arguments to \a PIConfig::Entry*
+	//! \~russian
 	virtual bool configureDevice(const void * e_main, const void * e_parent = 0) {return true;}
 	
-	//! Reimplement to open device, return value will be set to "opened_" variable; don't call this function in subclass, use open()
+	//! \~english Reimplement to open device, return value will be set to "opened_" variable.
+	//! Don't call this function in subclass, use \a open()!
+	//! \~russian Переопределите для открытия устройства, возвращаемое значение будет установлено в
+	//! переменную "opened_". Не используйте напрямую, только через \a open()!
 	virtual bool openDevice() = 0; // use path_, type_, opened_, init_ variables
 	
-	//! Reimplement to close device, inverse return value will be set to "opened_" variable
+	//! \~english Reimplement to close device, inverse return value will be set to "opened_" variable
+	//! \~russian Переопределите для закрытия устройства, обратное возвращаемое значение будет установлено в переменную "opened_"
 	virtual bool closeDevice() {return true;} // use path_, type_, opened_, init_ variables
 
-	//! Reimplement this function to read from your device
+	//! \~english Reimplement this function to read from your device
+	//! \~russian Переопределите для чтения данных из устройства
 	virtual int readDevice(void * read_to, int max_size) {piCoutObj << "\"read\" is not implemented!"; return -2;}
 
-	//! Reimplement this function to write to your device
+	//! \~english Reimplement this function to write to your device
+	//! \~russian Переопределите для записи данных в устройство
 	virtual int writeDevice(const void * data, int max_size) {piCoutObj << "\"write\" is not implemented!"; return -2;}
 
-	//! Function executed when thread read some data, default implementation execute external slot "ret_func_"
+	//! \~english Function executed when thread read some data, default implementation execute external callback "ret_func_"
+	//! \~russian Метод вызывается после каждого успешного потокового чтения, по умолчанию вызывает callback "ret_func_"
 	virtual bool threadedRead(uchar * readed, int size);
 	
-	//! Reimplement to construct full unambiguous string, describes this device. Default implementation returns \a path()
+	//! \~english Reimplement to construct full unambiguous string, describes this device.
+	//! Default implementation returns \a path()
+	//! \~russian Переопределите для создания строки полного описания устройства.
+	//! По умолчанию возвращает \a path()
 	virtual PIString constructFullPathDevice() const {return path();}
 
-	//! Reimplement to configure your device with parameters of full unambiguous string. Default implementation does nothing
+	//! \~english Reimplement to configure your device with parameters of full unambiguous string.
+	//! Default implementation call \a setPath()
+	//! \~russian Переопределите для настройки устройства из строки полного описания.
+	//! По умолчанию вызывает \a setPath()
 	virtual void configureFromFullPathDevice(const PIString & full_path) {setPath(full_path);}
 
-	//! Reimplement to construct device properties.
+	//! \~english Reimplement to construct device properties.
 	//! Default implementation return PIPropertyStorage with \"path\" entry
+	//! \~russian Переопределите для создания свойств устройства.
+	//! По умолчанию возвращает PIPropertyStorage со свойством \"path\"
 	virtual PIPropertyStorage constructVariantDevice() const;
 
-	//! Reimplement to configure your device from PIPropertyStorage. Options and mode already applied.
+	//! \~english Reimplement to configure your device from PIPropertyStorage. Options and mode already applied.
 	//! Default implementation apply \"path\" entry
+	//! \~russian Переопределите для настройки устройства из PIPropertyStorage. Опции и режим уже применены.
+	//! По умолчанию устанавливает свойство \"path\"
 	virtual void configureFromVariantDevice(const PIPropertyStorage & d);
 
-	//! Reimplement to apply new device options
+	//! \~english Reimplement to apply new device options
+	//! \~russian Переопределите для применения новых опций устройства
 	virtual void optionsChanged() {;}
 
-	//! Reimplement to return correct \a DeviceInfoFlags. Default implementation returns 0
+	//! \~english Reimplement to return correct \a DeviceInfoFlags. Default implementation returns 0
+	//! \~russian Переопределите для возврата правильных \a DeviceInfoFlags. По умолчанию возвращает 0
 	virtual DeviceInfoFlags deviceInfoFlags() const {return 0;}
 
-	//! Reimplement to apply new \a threadedReadBufferSize()
+	//! \~english Reimplement to apply new \a threadedReadBufferSize()
+	//! \~russian Переопределите для применения нового \a threadedReadBufferSize()
 	virtual void threadedReadBufferSizeChanged() {;}
 
-	//! Invoked after hard read thread stop
+	//! \~english Invoked after hard read thread stop
+	//! \~russian Вызывается после жесткой остановки потока чтения
 	virtual void threadedReadTerminated() {;}
 
-	//! Invoked after hard write thread stop
+	//! \~english Invoked after hard write thread stop
+	//! \~russian Вызывается после жесткой остановки потока записи
 	virtual void threadedWriteTerminated() {;}
 
 	static PIIODevice * newDeviceByPrefix(const char * prefix);