Merge branch 'master' of git.eter:/projects/asu/uniset2

extensions/SMDBServer/main.cc

@@ -29,9 +29,9 @@ int main( int argc, const char** argv )
         string logfilename(conf->getArgParam("--smdbserver-logfile"));
         if( logfilename.empty() )
             logfilename = "smdbserver.log";
-
+    
         conf->initDebug(dlog,"dlog");
-
+    
         std::ostringstream logname;
         string dir(conf->getLogDir());
         logname << dir << logfilename;
@@ -61,7 +61,7 @@ int main( int argc, const char** argv )
         UniSetActivator act;
         act.addObject(static_cast<class UniSetObject*>(db));
 
-        SystemMessage sm(SystemMessage::StartUp);
+        SystemMessage sm(SystemMessage::StartUp); 
         act.broadcast( sm.transport_msg() );
 
         ulog << "\n\n\n";

extensions/SharedMemoryPlus/Makefile.am

@@ -28,3 +28,4 @@ bin_PROGRAMS 		= @PACKAGE@-smemory-plus
 	$(SIGC_CFLAGS) $(COMCPP_CFLAGS)
 
 @PACKAGE@_smemory_plus_SOURCES = smemory-plus.cc
+

extensions/UNetUDP/UNetExchange.h

@@ -23,18 +23,18 @@
         - \ref pgUNetUDP_Reserv
 
     \section pgUNetUDP_Common Общее описание
-        Обмен построен  на основе протокола UDP.
+        Обмен построен  на основе протокола UDP. 
         Основная идея заключается в том, что каждый узел на порту равном своему ID
     посылает в сеть UDP-пакеты содержащие данные считанные из локальной SM. Формат данных - это набор
-    пар [id,value]. Другие узлы принимают их. Помимо этого данный процесс запускает
+    пар [id,value]. Другие узлы принимают их. Помимо этого данный процесс запускает 
     по потоку приёма для каждого другого узла и ловит пакеты от них, сохраняя данные в SM.
 
-    \par
-        При своём старте процесс считывает из секции \<nodes> список узлов которые необходимо "слушать",
+    \par 
+        При своём старте процесс считывает из секции \<nodes> список узлов которые необходимо "слушать", 
     а также параметры своего узла. Открывает по потоку приёма на каждый узел и поток
     передачи для своих данных. Помимо этого такие же потоки для резервных каналов, если они включены
     (см. \ref pgUNetUDP_Reserv ).
-
+    
     \section pgUNetUDP_Conf Пример конфигурирования
         По умолчанию при считывании используется \b unet_broadcast_ip (указанный в секции \<nodes>)
     и \b id узла - в качестве порта.
@@ -55,22 +55,22 @@
     \section pgUNetUDP_Reserv Настройка резервного канала связи
         В текущей реализации поддерживается возможность обмена по двум подсетям (эзернет-каналам).
     Она основана на том, что, для каждого узла помимо основного "читателя",
-    создаётся дополнительный "читатель"(поток) слушающий другой ip-адрес и порт.
-    А так же, для локального узла создаётся дополнительный "писатель"(поток),
-    который посылает данные в (указанную) вторую подсеть. Для того, чтобы задействовать
+    создаётся дополнительный "читатель"(поток) слушающий другой ip-адрес и порт. 
+    А так же, для локального узла создаётся дополнительный "писатель"(поток), 
+    который посылает данные в (указанную) вторую подсеть. Для того, чтобы задействовать 
     второй канал, достаточно объявить в настройках переменные
-    \b unet_broadcast_ip2. А также в случае необходимости для конкретного узла
+    \b unet_broadcast_ip2. А также в случае необходимости для конкретного узла 
     можно указать \b unet_broadcast_ip2 и \b unet_port2.
 
     Переключение между "каналами" происходит по следующей логике:
 
-    При старте включается только первый канал. Второй канал работает в режиме "пассивного" чтения.
-    Т.е. все пакеты принимаются, но данные в SharedMemory не сохраняются.
-    Если во время работы пропадает связь по первому каналу, идёт переключение на второй канал.
+    При старте включается только первый канал. Второй канал работает в режиме "пассивного" чтения. 
+    Т.е. все пакеты принимаются, но данные в SharedMemory не сохраняются. 
+    Если во время работы пропадает связь по первому каналу, идёт переключение на второй канал. 
     Первый канал переводиться в "пассивный" режим, а второй канал, переводится в "нормальный"(активный)
-    режим. Далее работа ведётся по второму каналу, независимо от того, что связь на первом
-    канале может восстановиться. Это сделано для защиты от постоянных перескакиваний
-    с канала на канал. Работа на втором канале будет вестись, пока не пропадёт связь
+    режим. Далее работа ведётся по второму каналу, независимо от того, что связь на первом 
+    канале может восстановиться. Это сделано для защиты от постоянных перескакиваний 
+    с канала на канал. Работа на втором канале будет вестись, пока не пропадёт связь 
     на нём. Тогда будет попытка переключиться обратно на первый канал и так "по кругу".
 
     В свою очередь "писатели"(если они не отключены) всегда посылают данные в оба канала.
@@ -158,8 +158,8 @@ class UNetExchange:
             void step( SMInterface* shm, const std::string& myname );
 
             inline void setRespondID( UniSetTypes::ObjectId id, bool invert=false )
-            {
-                sidRespond = id;
+            { 
+                sidRespond = id; 
                 respondInvert = invert;
             }
             inline void setLostPacketsID( UniSetTypes::ObjectId id ){ sidLostPackets = id; }

extensions/lib/Extensions.cc

@@ -28,7 +28,7 @@ namespace UniSetExtensions
             dcrit << err.str() << endl;
             throw SystemError(err.str());
         }
-
+    
         // cout << "(uniset): shm=" << name << " id=" << shmID << endl;
         return shmID;
     }
@@ -39,7 +39,7 @@ namespace UniSetExtensions
             return;
 
         string::size_type pos = s.find("\\n");
-
+        
         while( pos != string::npos )
         {
             s.replace(pos,2,"\n");
@@ -53,10 +53,10 @@ namespace UniSetExtensions
     {
         if( xmlCalibrationsNode )
             return xmlCalibrationsNode;
-
+        
         xmlCalibrationsNode = conf->getNode("Calibrations");
         return xmlCalibrationsNode;
-
+        
     }
     // -------------------------------------------------------------------------
 
@@ -64,7 +64,7 @@ namespace UniSetExtensions
     {
         if( !node )
             return 0;
-
+    
         UniXML_iterator it(node);
         if( !it.goChildren() )
             return 0;

extensions/tests/SMemoryTest/test.xml

+../../../conf/test.xml
\ No newline at end of file

include/RunLock.h

@@ -33,20 +33,20 @@
     unlock() - удаляет файл.
 
 \warning Код не переносимый, т.к. рассчитан на наличие каталога /proc,
-по которому проверяется статус процесса (по pid).
+по которому проверяется статус процесса (по pid). 
 */
 class RunLock
 {
     public:
         RunLock();
         ~RunLock();
-
+        
         static bool isLocked(const std::string& lockFile); //, char* **argv );
         static bool lock(const std::string& lockFile);
         static bool unlock(const std::string& lockFile);
-
+        
     protected:
-
+    
 };
 // ----------------------------------------------------------------------------
 #endif

include/UniSetManager_LT.h

@@ -31,7 +31,7 @@
 //---------------------------------------------------------------------------
 /*!
     Реализация базового класса с использованием локальных таймеров
-*/
+*/ 
 class UniSetManager_LT:
     public UniSetManager
 {

include/modbus/ModbusHelpers.h

@@ -10,8 +10,8 @@ class ModbusRTUMaster;
 // -------------------------------------------------------------------------
 namespace ModbusHelpers
 {
-    ModbusRTU::ModbusAddr autodetectSlave( ModbusRTUMaster* m,
-                                            ModbusRTU::ModbusAddr beg=0,
+    ModbusRTU::ModbusAddr autodetectSlave( ModbusRTUMaster* m, 
+                                            ModbusRTU::ModbusAddr beg=0, 
                                             ModbusRTU::ModbusAddr end=255,
                                             ModbusRTU::ModbusData reg=0,
                                             ModbusRTU::SlaveFunctionCode fn=ModbusRTU::fnReadInputRegisters
@@ -19,7 +19,7 @@ namespace ModbusHelpers
 
     ModbusRTU::ModbusAddr autodetectSlave( std::string dev,
                                             ComPort::Speed s, int tout=1000,
-                                            ModbusRTU::ModbusAddr beg=0,
+                                            ModbusRTU::ModbusAddr beg=0, 
                                             ModbusRTU::ModbusAddr end=255,
                                             ModbusRTU::ModbusData reg=0,
                                             ModbusRTU::SlaveFunctionCode fn=ModbusRTU::fnReadInputRegisters
@@ -31,7 +31,7 @@ namespace ModbusHelpers
                                      ); // throw UniSetTypes::TimeOut();
 
     ComPort::Speed autodetectSpeed( std::string dev,
-                                    ModbusRTU::ModbusAddr slave,
+                                    ModbusRTU::ModbusAddr slave, 
                                     int timeout_msec=1000,
                                     ModbusRTU::ModbusData reg=0,
                                     ModbusRTU::SlaveFunctionCode fn=ModbusRTU::fnReadInputRegisters

include/modbus/ModbusRTUMaster.h

@@ -11,7 +11,7 @@
 #include "ModbusTypes.h"
 #include "ModbusClient.h"
 // -------------------------------------------------------------------------
-/*!    Modbus RTU master mode
+/*!    Modbus RTU master mode 
     \todo Добавить ведение статистики по ошибкам
 */
 class ModbusRTUMaster:
@@ -37,11 +37,11 @@ class ModbusRTUMaster:
 
     protected:
 
-        /*! get next data block from channel ot recv buffer
+        /*! get next data block from channel ot recv buffer 
             \param begin - get from position
             \param buf  - buffer for data
             \param len     - size of buf
-            \return real data lenght ( must be <= len )
+            \return real data lenght ( must be <= len ) 
         */
         virtual int getNextData( unsigned char* buf, int len ) override;
 
@@ -51,7 +51,7 @@ class ModbusRTUMaster:
         virtual ModbusRTU::mbErrCode sendData( unsigned char* buf, int len ) override;
 
         /*! функция запрос-ответ */
-        virtual ModbusRTU::mbErrCode query( ModbusRTU::ModbusAddr addr, ModbusRTU::ModbusMessage& msg,
+        virtual ModbusRTU::mbErrCode query( ModbusRTU::ModbusAddr addr, ModbusRTU::ModbusMessage& msg, 
                                             ModbusRTU::ModbusMessage& reply, timeout_t timeout ) override;
 
 

include/modbus/ModbusRTUSlave.h

@@ -11,11 +11,11 @@
 #include "ModbusTypes.h"
 #include "ModbusServer.h"
 // -------------------------------------------------------------------------
-/*!    Modbus RTU slave mode
+/*!    Modbus RTU slave mode  
     Класс не самостоятельный и содержит "чисто" виртуальные функции
     для реализации ответов на запросы.
 
-    \todo Разобратся с тем как отвечать на неправильные запросы!
+    \todo Разобратся с тем как отвечать на неправильные запросы! 
         Формат ответных сообщений!!! Коды ошибок!!!
     \todo Доработать terminate, чтобы можно было прервать ожидание
 */

include/modbus/ModbusRTUSlaveSlot.h

@@ -7,10 +7,10 @@
 #include "ModbusRTUSlave.h"
 #include "ModbusServerSlot.h"
 // -------------------------------------------------------------------------
-/*!
+/*!    
     Реализация позволяющая добавлять обработчики не наследуясь от ModbusRTUSlave.
     Основана на использовании слотов.
-    \warning Пока реализована возможность подключения ТОЛЬКО ОДНОГО обработчика
+    \warning Пока реализована возможность подключения ТОЛЬКО ОДНОГО обработчика 
 */
 class ModbusRTUSlaveSlot:
     public ModbusRTUSlave,
@@ -24,51 +24,51 @@ class ModbusRTUSlaveSlot:
         virtual void sigterm( int signo );
 
         inline ComPort* getComPort(){ return port; }
-
+    
     protected:
 
-        virtual ModbusRTU::mbErrCode readCoilStatus( ModbusRTU::ReadCoilMessage& query,
+        virtual ModbusRTU::mbErrCode readCoilStatus( ModbusRTU::ReadCoilMessage& query, 
                                                             ModbusRTU::ReadCoilRetMessage& reply );
 
-        virtual ModbusRTU::mbErrCode readInputStatus( ModbusRTU::ReadInputStatusMessage& query,
+        virtual ModbusRTU::mbErrCode readInputStatus( ModbusRTU::ReadInputStatusMessage& query, 
                                                             ModbusRTU::ReadInputStatusRetMessage& reply );
 
-        virtual ModbusRTU::mbErrCode readOutputRegisters( ModbusRTU::ReadOutputMessage& query,
+        virtual ModbusRTU::mbErrCode readOutputRegisters( ModbusRTU::ReadOutputMessage& query, 
                                                         ModbusRTU::ReadOutputRetMessage& reply );
 
-        virtual ModbusRTU::mbErrCode readInputRegisters( ModbusRTU::ReadInputMessage& query,
+        virtual ModbusRTU::mbErrCode readInputRegisters( ModbusRTU::ReadInputMessage& query, 
                                                             ModbusRTU::ReadInputRetMessage& reply );
 
-        virtual ModbusRTU::mbErrCode forceSingleCoil( ModbusRTU::ForceSingleCoilMessage& query,
+        virtual ModbusRTU::mbErrCode forceSingleCoil( ModbusRTU::ForceSingleCoilMessage& query, 
                                                         ModbusRTU::ForceSingleCoilRetMessage& reply );
 
-        virtual ModbusRTU::mbErrCode writeOutputSingleRegister( ModbusRTU::WriteSingleOutputMessage& query,
+        virtual ModbusRTU::mbErrCode writeOutputSingleRegister( ModbusRTU::WriteSingleOutputMessage& query, 
                                                         ModbusRTU::WriteSingleOutputRetMessage& reply );
 
-        virtual ModbusRTU::mbErrCode forceMultipleCoils( ModbusRTU::ForceCoilsMessage& query,
+        virtual ModbusRTU::mbErrCode forceMultipleCoils( ModbusRTU::ForceCoilsMessage& query, 
                                                         ModbusRTU::ForceCoilsRetMessage& reply );
 
-        virtual ModbusRTU::mbErrCode writeOutputRegisters( ModbusRTU::WriteOutputMessage& query,
+        virtual ModbusRTU::mbErrCode writeOutputRegisters( ModbusRTU::WriteOutputMessage& query, 
                                                         ModbusRTU::WriteOutputRetMessage& reply );
-
-        virtual ModbusRTU::mbErrCode diagnostics( ModbusRTU::DiagnosticMessage& query,
+        
+        virtual ModbusRTU::mbErrCode diagnostics( ModbusRTU::DiagnosticMessage& query, 
                                                         ModbusRTU::DiagnosticRetMessage& reply );
 
-        virtual ModbusRTU::mbErrCode read4314( ModbusRTU::MEIMessageRDI& query,
+        virtual ModbusRTU::mbErrCode read4314( ModbusRTU::MEIMessageRDI& query, 
                                                         ModbusRTU::MEIMessageRetRDI& reply );
 
-        virtual ModbusRTU::mbErrCode journalCommand( ModbusRTU::JournalCommandMessage& query,
+        virtual ModbusRTU::mbErrCode journalCommand( ModbusRTU::JournalCommandMessage& query, 
                                                         ModbusRTU::JournalCommandRetMessage& reply );
 
-        virtual ModbusRTU::mbErrCode setDateTime( ModbusRTU::SetDateTimeMessage& query,
+        virtual ModbusRTU::mbErrCode setDateTime( ModbusRTU::SetDateTimeMessage& query, 
                                                             ModbusRTU::SetDateTimeRetMessage& reply );
 
-        virtual ModbusRTU::mbErrCode remoteService( ModbusRTU::RemoteServiceMessage& query,
+        virtual ModbusRTU::mbErrCode remoteService( ModbusRTU::RemoteServiceMessage& query, 
                                                             ModbusRTU::RemoteServiceRetMessage& reply );
 
-        virtual ModbusRTU::mbErrCode fileTransfer( ModbusRTU::FileTransferMessage& query,
+        virtual ModbusRTU::mbErrCode fileTransfer( ModbusRTU::FileTransferMessage& query, 
                                                             ModbusRTU::FileTransferRetMessage& reply );
-
+    
     private:
 };
 // -------------------------------------------------------------------------

include/modbus/ModbusTCPMaster.h

@@ -39,7 +39,7 @@ class ModbusTCPMaster:
         virtual int getNextData( unsigned char* buf, int len ) override;
         virtual void setChannelTimeout( timeout_t msec ) override;
         virtual ModbusRTU::mbErrCode sendData( unsigned char* buf, int len ) override;
-        virtual ModbusRTU::mbErrCode query( ModbusRTU::ModbusAddr addr, ModbusRTU::ModbusMessage& msg,
+        virtual ModbusRTU::mbErrCode query( ModbusRTU::ModbusAddr addr, ModbusRTU::ModbusMessage& msg, 
                                             ModbusRTU::ModbusMessage& reply, timeout_t timeout ) override;
 
     private:

include/modbus/ModbusTCPServer.h

@@ -26,7 +26,7 @@ class ModbusTCPServer:
         /*! Однопоточная обработка (каждый запрос последовательно), с разрывом соединения в конце */
         virtual ModbusRTU::mbErrCode receive( ModbusRTU::ModbusAddr mbaddr, timeout_t msecTimeout ) override;
 
-        /*! Многопоточная обработка (создаётся по потоку для каждого "клиента")
+        /*! Многопоточная обработка (создаётся по потоку для каждого "клиента") 
          \ return TRUE - если запр*ос пришёл
          \return FALSE - если timeout
          */

include/modbus/ModbusTCPServerSlot.h

@@ -20,46 +20,46 @@ class ModbusTCPServerSlot:
 
     protected:
 
-        virtual ModbusRTU::mbErrCode readCoilStatus( ModbusRTU::ReadCoilMessage& query,
+        virtual ModbusRTU::mbErrCode readCoilStatus( ModbusRTU::ReadCoilMessage& query, 
                                                             ModbusRTU::ReadCoilRetMessage& reply );
 
-        virtual ModbusRTU::mbErrCode readInputStatus( ModbusRTU::ReadInputStatusMessage& query,
+        virtual ModbusRTU::mbErrCode readInputStatus( ModbusRTU::ReadInputStatusMessage& query, 
                                                             ModbusRTU::ReadInputStatusRetMessage& reply );
 
-        virtual ModbusRTU::mbErrCode readOutputRegisters( ModbusRTU::ReadOutputMessage& query,
+        virtual ModbusRTU::mbErrCode readOutputRegisters( ModbusRTU::ReadOutputMessage& query, 
                                                         ModbusRTU::ReadOutputRetMessage& reply );
 
-        virtual ModbusRTU::mbErrCode readInputRegisters( ModbusRTU::ReadInputMessage& query,
+        virtual ModbusRTU::mbErrCode readInputRegisters( ModbusRTU::ReadInputMessage& query, 
                                                             ModbusRTU::ReadInputRetMessage& reply );
 
-        virtual ModbusRTU::mbErrCode forceSingleCoil( ModbusRTU::ForceSingleCoilMessage& query,
+        virtual ModbusRTU::mbErrCode forceSingleCoil( ModbusRTU::ForceSingleCoilMessage& query, 
                                                         ModbusRTU::ForceSingleCoilRetMessage& reply );
 
-        virtual ModbusRTU::mbErrCode writeOutputSingleRegister( ModbusRTU::WriteSingleOutputMessage& query,
+        virtual ModbusRTU::mbErrCode writeOutputSingleRegister( ModbusRTU::WriteSingleOutputMessage& query, 
                                                         ModbusRTU::WriteSingleOutputRetMessage& reply );
 
-        virtual ModbusRTU::mbErrCode forceMultipleCoils( ModbusRTU::ForceCoilsMessage& query,
+        virtual ModbusRTU::mbErrCode forceMultipleCoils( ModbusRTU::ForceCoilsMessage& query, 
                                                         ModbusRTU::ForceCoilsRetMessage& reply );
 
-        virtual ModbusRTU::mbErrCode writeOutputRegisters( ModbusRTU::WriteOutputMessage& query,
+        virtual ModbusRTU::mbErrCode writeOutputRegisters( ModbusRTU::WriteOutputMessage& query, 
                                                         ModbusRTU::WriteOutputRetMessage& reply );
 
-        virtual ModbusRTU::mbErrCode diagnostics( ModbusRTU::DiagnosticMessage& query,
+        virtual ModbusRTU::mbErrCode diagnostics( ModbusRTU::DiagnosticMessage& query, 
                                                         ModbusRTU::DiagnosticRetMessage& reply );
 
-        virtual ModbusRTU::mbErrCode read4314( ModbusRTU::MEIMessageRDI& query,
+        virtual ModbusRTU::mbErrCode read4314( ModbusRTU::MEIMessageRDI& query, 
                                                         ModbusRTU::MEIMessageRetRDI& reply );
 
-        virtual ModbusRTU::mbErrCode journalCommand( ModbusRTU::JournalCommandMessage& query,
+        virtual ModbusRTU::mbErrCode journalCommand( ModbusRTU::JournalCommandMessage& query, 
                                                         ModbusRTU::JournalCommandRetMessage& reply );
 
-        virtual ModbusRTU::mbErrCode setDateTime( ModbusRTU::SetDateTimeMessage& query,
+        virtual ModbusRTU::mbErrCode setDateTime( ModbusRTU::SetDateTimeMessage& query, 
                                                             ModbusRTU::SetDateTimeRetMessage& reply );
 
-        virtual ModbusRTU::mbErrCode remoteService( ModbusRTU::RemoteServiceMessage& query,
+        virtual ModbusRTU::mbErrCode remoteService( ModbusRTU::RemoteServiceMessage& query, 
                                                             ModbusRTU::RemoteServiceRetMessage& reply );
 
-        virtual ModbusRTU::mbErrCode fileTransfer( ModbusRTU::FileTransferMessage& query,
+        virtual ModbusRTU::mbErrCode fileTransfer( ModbusRTU::FileTransferMessage& query, 
                                                             ModbusRTU::FileTransferRetMessage& reply );
 
     private:

include/modbus/ModbusTCPSession.h

@@ -46,46 +46,46 @@ class ModbusTCPSession:
         virtual ModbusRTU::mbErrCode post_send_request( ModbusRTU::ModbusMessage& request );
 
 
-        virtual ModbusRTU::mbErrCode readCoilStatus( ModbusRTU::ReadCoilMessage& query,
+        virtual ModbusRTU::mbErrCode readCoilStatus( ModbusRTU::ReadCoilMessage& query, 
                                                             ModbusRTU::ReadCoilRetMessage& reply );
 
-        virtual ModbusRTU::mbErrCode readInputStatus( ModbusRTU::ReadInputStatusMessage& query,
+        virtual ModbusRTU::mbErrCode readInputStatus( ModbusRTU::ReadInputStatusMessage& query, 
                                                             ModbusRTU::ReadInputStatusRetMessage& reply );
 
-        virtual ModbusRTU::mbErrCode readOutputRegisters( ModbusRTU::ReadOutputMessage& query,
+        virtual ModbusRTU::mbErrCode readOutputRegisters( ModbusRTU::ReadOutputMessage& query, 
                                                         ModbusRTU::ReadOutputRetMessage& reply );
 
-        virtual ModbusRTU::mbErrCode readInputRegisters( ModbusRTU::ReadInputMessage& query,
+        virtual ModbusRTU::mbErrCode readInputRegisters( ModbusRTU::ReadInputMessage& query, 
                                                             ModbusRTU::ReadInputRetMessage& reply );
 
-        virtual ModbusRTU::mbErrCode forceSingleCoil( ModbusRTU::ForceSingleCoilMessage& query,
+        virtual ModbusRTU::mbErrCode forceSingleCoil( ModbusRTU::ForceSingleCoilMessage& query, 
                                                         ModbusRTU::ForceSingleCoilRetMessage& reply );
 
-        virtual ModbusRTU::mbErrCode writeOutputSingleRegister( ModbusRTU::WriteSingleOutputMessage& query,
+        virtual ModbusRTU::mbErrCode writeOutputSingleRegister( ModbusRTU::WriteSingleOutputMessage& query, 
                                                         ModbusRTU::WriteSingleOutputRetMessage& reply );
 
-        virtual ModbusRTU::mbErrCode forceMultipleCoils( ModbusRTU::ForceCoilsMessage& query,
+        virtual ModbusRTU::mbErrCode forceMultipleCoils( ModbusRTU::ForceCoilsMessage& query, 
                                                         ModbusRTU::ForceCoilsRetMessage& reply );
 
-        virtual ModbusRTU::mbErrCode writeOutputRegisters( ModbusRTU::WriteOutputMessage& query,
+        virtual ModbusRTU::mbErrCode writeOutputRegisters( ModbusRTU::WriteOutputMessage& query, 
                                                         ModbusRTU::WriteOutputRetMessage& reply );
 
-        virtual ModbusRTU::mbErrCode diagnostics( ModbusRTU::DiagnosticMessage& query,
+        virtual ModbusRTU::mbErrCode diagnostics( ModbusRTU::DiagnosticMessage& query, 
                                                         ModbusRTU::DiagnosticRetMessage& reply );
 
-        virtual ModbusRTU::mbErrCode read4314( ModbusRTU::MEIMessageRDI& query,
+        virtual ModbusRTU::mbErrCode read4314( ModbusRTU::MEIMessageRDI& query, 
                                                         ModbusRTU::MEIMessageRetRDI& reply );
 
-        virtual ModbusRTU::mbErrCode journalCommand( ModbusRTU::JournalCommandMessage& query,
+        virtual ModbusRTU::mbErrCode journalCommand( ModbusRTU::JournalCommandMessage& query, 
                                                         ModbusRTU::JournalCommandRetMessage& reply );
 
-        virtual ModbusRTU::mbErrCode setDateTime( ModbusRTU::SetDateTimeMessage& query,
+        virtual ModbusRTU::mbErrCode setDateTime( ModbusRTU::SetDateTimeMessage& query, 
                                                             ModbusRTU::SetDateTimeRetMessage& reply );
 
-        virtual ModbusRTU::mbErrCode remoteService( ModbusRTU::RemoteServiceMessage& query,
+        virtual ModbusRTU::mbErrCode remoteService( ModbusRTU::RemoteServiceMessage& query, 
                                                             ModbusRTU::RemoteServiceRetMessage& reply );
 
-        virtual ModbusRTU::mbErrCode fileTransfer( ModbusRTU::FileTransferMessage& query,
+        virtual ModbusRTU::mbErrCode fileTransfer( ModbusRTU::FileTransferMessage& query, 
                                                             ModbusRTU::FileTransferRetMessage& reply );
 
     private:

include/modbus/TCPCheck.h

@@ -16,9 +16,9 @@ class TCPCheck
     public:
         TCPCheck();
         ~TCPCheck();
-
+    
         bool check( const std::string& _ip, int _port, timeout_t tout, timeout_t sleep_msec );
-
+        
         /*! \param iaddr - 'ip:port' */
         bool check( const std::string& iaddr, timeout_t tout, timeout_t sleep_msec );
 

python/lib/pyUniSet/Makefile.am

@@ -21,7 +21,7 @@ UConnector_wrap.cxx: UConnector.i UConnector.h
 	swig -python -c++ -classic UConnector.i
 
 _pyUModbus_la_SOURCES 	= UModbus.cc UModbus_wrap.cxx
-_pyUModbus_la_CXXFLAGS	= $(UNISET_CFLAGS) $(UNISET_EXT_CFLAGS) $(COMCPP_CFLAGS) $(PYTHON_CFLAGS)
+_pyUModbus_la_CXXFLAGS	= $(UNISET_CFLAGS) $(UNISET_EXT_CFLAGS) $(COMCPP_CFLAGS) $(PYTHON_CFLAGS) 
 _pyUModbus_la_LDFLAGS 	= -module -avoid-version
 _pyUModbus_la_LIBADD 	= $(UNISET_LIBS) $(UNISET_EXT_LIBS) $(COMCPP_LIBS) $(PYTHON_LIBS)
 

python/lib/pyUniSet/PyUInterface.h

 #ifndef pyUInterface_H_
 #define pyUInterface_H_
-// --------------------------------------------------------------------------
+// -------------------------------------------------------------------------- 
 #include <string>
 #include "UTypes.h"
 #include "UExceptions.h"
-// --------------------------------------------------------------------------
+// -------------------------------------------------------------------------- 
 namespace pyUInterface
 {
     void uniset_init_params( UTypes::Params* p, const char* xmlfile )throw(UException);
@@ -15,13 +15,13 @@ namespace pyUInterface
     void setValue( long id, long val )throw(UException);
 
     long getSensorID( const char* );
-
+    
     const char* getShortName( long id );
     const char* getName( long id );
     const char* getTextName( long id );
-
+    
     const char* getConfFileName();
-
+    
 }
 //---------------------------------------------------------------------------
 #endif

python/lib/pyUniSet/UConnector.cc

@@ -54,7 +54,7 @@ const char* UConnector::getConfFileName()
 //    return xmlfile;
     if( conf )
         return conf->getConfFileName().c_str();
-
+        
     return "";
 
 }
@@ -63,10 +63,10 @@ long UConnector::getValue( long id, long node )throw(UException)
 {
     if( !conf || !ui )
       throw USysError();
-
+    
     if( node == UTypes::DefaultID )
       node = conf->getLocalNode();
-
+    
     try
     {
          return ui->getValue(id,node);
@@ -79,7 +79,7 @@ long UConnector::getValue( long id, long node )throw(UException)
     {
         throw UException("(getValue): catch...");
     }
-
+    
     throw UException("(getValue): unknown error");
 }
 //---------------------------------------------------------------------------
@@ -87,11 +87,11 @@ void UConnector::setValue( long id, long val, long node )throw(UException)
 {
     if( !conf || !ui )
       throw USysError();
-
-
+    
+    
     if( node == UTypes::DefaultID )
       node = conf->getLocalNode();
-
+    
     try
     {
         ui->setValue(id,val,node);
@@ -110,7 +110,7 @@ long UConnector::getSensorID( const char* name )
 {
     if( conf )
       return conf->getSensorID(name);
-
+    
     return UTypes::DefaultID;
 }
 //---------------------------------------------------------------------------
@@ -118,7 +118,7 @@ long UConnector::getNodeID( const char* name )
 {
     if( conf )
       return conf->getNodeID(name);
-
+    
     return UTypes::DefaultID;
 }
 //---------------------------------------------------------------------------
@@ -126,7 +126,7 @@ const char* UConnector::getName( long id )
 {
     if( conf )
         return conf->oind->getMapName(id).c_str();
-
+        
     return "";
 }
 //---------------------------------------------------------------------------
@@ -134,7 +134,7 @@ const char* UConnector::getShortName( long id )
 {
     if( conf )
         return ORepHelpers::getShortName(conf->oind->getMapName(id)).c_str();
-
+        
     return "";
 }
 //---------------------------------------------------------------------------
@@ -142,7 +142,7 @@ const char* UConnector::getTextName( long id )
 {
     if( conf )
         return conf->oind->getTextName(id).c_str();
-
+        
     return "";
 }
 //---------------------------------------------------------------------------

python/lib/pyUniSet/UConnector.h

@@ -22,12 +22,12 @@ class UConnector
 
       long getSensorID( const char* );
       long getNodeID( const char* );
-
+    
       const char* getShortName( long id );
       const char* getName( long id );
       const char* getTextName( long id );
 
-
+      
     private:
       UniSetTypes::Configuration* conf;
       UInterface* ui;

python/lib/pyUniSet/UConnector_wrap.cxx

@@ -2980,7 +2980,7 @@ static swig_module_info swig_module = {swig_types, 5, 0, 0, 0, 0};
 #endif
 #define SWIG_name    "_pyUConnector"
 
-#define SWIGVERSION 0x020010
+#define SWIGVERSION 0x020010 
 #define SWIG_VERSION SWIGVERSION
 
 

python/lib/pyUniSet/UExceptions.h

@@ -7,9 +7,9 @@ struct UException
     UException( const std::string& e ):err(e){}
     UException( const char* e ):err( std::string(e)){}
     ~UException(){}
-
+    
     const char* getError(){ return err.c_str(); }
-
+    
     std::string err;
 };
 //---------------------------------------------------------------------------

python/lib/pyUniSet/UExceptions_wrap.cxx

@@ -2980,7 +2980,7 @@ static swig_module_info swig_module = {swig_types, 5, 0, 0, 0, 0};
 #endif
 #define SWIG_name    "_pyUExceptions"
 
-#define SWIGVERSION 0x020010
+#define SWIGVERSION 0x020010 
 #define SWIG_VERSION SWIGVERSION
 
 

python/lib/pyUniSet/UInterface_wrap.cxx

@@ -2982,7 +2982,7 @@ static swig_module_info swig_module = {swig_types, 7, 0, 0, 0, 0};
 #endif
 #define SWIG_name    "_pyUniSet"
 
-#define SWIGVERSION 0x020010
+#define SWIGVERSION 0x020010 
 #define SWIG_VERSION SWIGVERSION
 
 
@@ -3834,10 +3834,10 @@ SWIGINTERN PyObject *_wrap_new_UException__SWIG_1(PyObject *SWIGUNUSEDPARM(self)
   if (!PyArg_ParseTuple(args,(char *)"O:new_UException",&obj0)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__string,  0  | 0);
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UException" "', argument " "1"" of type '" "std::string const &""'");
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UException" "', argument " "1"" of type '" "std::string const &""'"); 
   }
   if (!argp1) {
-    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UException" "', argument " "1"" of type '" "std::string const &""'");
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UException" "', argument " "1"" of type '" "std::string const &""'"); 
   }
   arg1 = reinterpret_cast< std::string * >(argp1);
   result = (UException *)new UException((std::string const &)*arg1);
@@ -4047,10 +4047,10 @@ SWIGINTERN PyObject *_wrap_new_UTimeOut__SWIG_1(PyObject *SWIGUNUSEDPARM(self),
   if (!PyArg_ParseTuple(args,(char *)"O:new_UTimeOut",&obj0)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__string,  0  | 0);
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UTimeOut" "', argument " "1"" of type '" "std::string const &""'");
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UTimeOut" "', argument " "1"" of type '" "std::string const &""'"); 
   }
   if (!argp1) {
-    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UTimeOut" "', argument " "1"" of type '" "std::string const &""'");
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UTimeOut" "', argument " "1"" of type '" "std::string const &""'"); 
   }
   arg1 = reinterpret_cast< std::string * >(argp1);
   result = (UTimeOut *)new UTimeOut((std::string const &)*arg1);
@@ -4144,10 +4144,10 @@ SWIGINTERN PyObject *_wrap_new_USysError__SWIG_1(PyObject *SWIGUNUSEDPARM(self),
   if (!PyArg_ParseTuple(args,(char *)"O:new_USysError",&obj0)) SWIG_fail;
   res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__string,  0  | 0);
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_USysError" "', argument " "1"" of type '" "std::string const &""'");
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_USysError" "', argument " "1"" of type '" "std::string const &""'"); 
   }
   if (!argp1) {
-    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_USysError" "', argument " "1"" of type '" "std::string const &""'");
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_USysError" "', argument " "1"" of type '" "std::string const &""'"); 
   }
   arg1 = reinterpret_cast< std::string * >(argp1);
   result = (USysError *)new USysError((std::string const &)*arg1);

python/lib/pyUniSet/UModbus.cc

@@ -105,7 +105,7 @@ void UModbus::connect( const char* _ip, int _port )throw(UException)
         std::ostringstream err;
         err << "Connection failed: ip=" << ip << " port=" << port;
         throw UException(err.str());
-    }
+    }    
 }
 // --------------------------------------------------------------------------
 long UModbus::getWord( int addr, int mbreg, int mbfunc )throw(UException)
@@ -130,10 +130,10 @@ long UModbus::mbread( int mbaddr, int mbreg, int mbfunc, const char* s_vtype, in
 
 //    const char* n_ip = strcmp(new_ip,"") ? new_ip : ip;
     const char* n_ip = (new_ip != 0) ? new_ip : ip.c_str();
-    int n_port = ( new_port > 0 ) ? new_port : port;
+    int n_port = ( new_port > 0 ) ? new_port : port;    
 
     connect(n_ip,n_port);
-
+    
     VType vt = str2type(s_vtype);
     if( vt == vtUnknown )
     {
@@ -217,7 +217,7 @@ long UModbus::mbread( int mbaddr, int mbreg, int mbfunc, const char* s_vtype, in
 //---------------------------------------------------------------------------
 long UModbus::data2value( VTypes::VType vtype, ModbusRTU::ModbusData* data )
 {
-#if 0
+#if 0    
     if( vt == VTypes::vtUnknown )
     {
         ModbusRTU::DataBits16 b(data[0]);

python/lib/pyUniSet/UModbus.h

@@ -24,7 +24,7 @@ class UModbus
 
       // выставление паметров связи, без установления соединения (!)
       void prepare( const char* ip, int port )throw(UException);
-
+      
       void connect( const char* ip, int port )throw(UException);
       inline int conn_port(){ return port; }
       inline std::string conn_ip(){ return ip; }
@@ -32,7 +32,7 @@ class UModbus
 
       inline void setTimeout( int msec ){ tout_msec = msec; }
 
-      /*! Универсальная функция для чтения регистров.
+      /*! Универсальная функция для чтения регистров. 
        * Если не указывать ip и порт, будут использованы, те
        * чтобы были заданы в UModbus::connect(). Если заданы другие ip и port,
        * будет сделано переподключение..
@@ -54,7 +54,7 @@ class UModbus
 
     protected:
         long data2value( VTypes::VType vt, ModbusRTU::ModbusData* data );
-
+    
     private:
         // DebugStream dlog;
         ModbusTCPMaster* mb;

python/lib/pyUniSet/UTypes.h

@@ -6,7 +6,7 @@
 namespace UTypes
 {
     const long DefaultID = UniSetTypes::DefaultObjectId;
-
+    
     struct Params
     {
         static const int max = 20;
@@ -25,7 +25,7 @@ namespace UTypes
 
         int argc;
         char* argv[max];
-
+        
         static Params inst(){ return Params(); }
     };
 }

python/lib/pyUniSet/pyUModbus.py

@@ -117,7 +117,7 @@ class UException(Exception):
     __swig_getmethods__ = {}
     __getattr__ = lambda self, name: _swig_getattr(self, UException, name)
     __repr__ = _swig_repr
-    def __init__(self, *args):
+    def __init__(self, *args): 
         this = _pyUModbus.new_UException(*args)
         try: self.this.append(this)
         except: self.this = this
@@ -137,7 +137,7 @@ class UTimeOut(UException):
     for _s in [UException]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
     __getattr__ = lambda self, name: _swig_getattr(self, UTimeOut, name)
     __repr__ = _swig_repr
-    def __init__(self, *args):
+    def __init__(self, *args): 
         this = _pyUModbus.new_UTimeOut(*args)
         try: self.this.append(this)
         except: self.this = this
@@ -154,7 +154,7 @@ class USysError(UException):
     for _s in [UException]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
     __getattr__ = lambda self, name: _swig_getattr(self, USysError, name)
     __repr__ = _swig_repr
-    def __init__(self, *args):
+    def __init__(self, *args): 
         this = _pyUModbus.new_USysError(*args)
         try: self.this.append(this)
         except: self.this = this

src/Communications/ComPort.cc

@@ -53,12 +53,12 @@ void ComPort::openPort()
         string strErr="Unable to open "+dev+" [Error: "+strerror(errno)+"]";
         throw UniSetTypes::SystemError(strErr.c_str());
     }
-
+    
      /* Get the current options for the port */
     tcgetattr(fd, &options);
 
     oldTermios=options;
-
+    
     cfsetispeed(&options, B19200);          /* Set the baud rates to 19200 */
     cfsetospeed(&options, B19200);
 
@@ -93,7 +93,7 @@ void ComPort::reopen()
         openPort();
         if( fd > 0 )
             tcsetattr(fd, TCSAFLUSH, &options);
-    }
+    }    
 }
 // --------------------------------------------------------------------------------
 void ComPort::setSpeed( Speed s )
@@ -114,7 +114,7 @@ void ComPort::setParity(Parity parity)
     struct termios options;
 
     tcgetattr(fd, &options);
-
+    
     switch(parity)
     {
     case Odd:
@@ -205,14 +205,14 @@ unsigned char ComPort::m_receiveByte( bool wait )
         {
             fd_set set;
             timeval timeout;
-
+            
             FD_ZERO (&set);
             FD_SET (fd, &set);
-
+            
             /* Initialize the timeout data structure. */
             timeout.tv_sec = 0;
             timeout.tv_usec = uTimeout;
-
+            
             /* select' returns 0 if timeout, 1 if input available, -1 if error. */
 
             if(select(FD_SETSIZE, &set, NULL, NULL, &timeout)==1)
@@ -287,10 +287,10 @@ int ComPort::sendBlock(unsigned char* msg, int len)
 int ComPort::receiveBlock(unsigned char* msg, int len)
 {
     int k;
-
+    
     if(!len)
         return 0;
-
+    
     for(k=0;k<len;k++)
     {
         try
@@ -302,12 +302,12 @@ int ComPort::receiveBlock(unsigned char* msg, int len)
             break;
         }
     }
-
+    
     if(!k)
     {
         throw UniSetTypes::TimeOut();
     }
-
+    
     return k;
 }
 
@@ -424,13 +424,13 @@ std::string ComPort::getSpeed( Speed s )
 // --------------------------------------------------------------------------------
 #define CHECK_SPEED(var,speed) \
     if( var == __STRING(speed) ) \
-        return ComPort::ComSpeed##speed;
-
+        return ComPort::ComSpeed##speed; 
+        
 ComPort::Speed ComPort::getSpeed( const string& s )
 {
-    // см. ComPort.h
+    // см. ComPort.h    
 
-    // сперва самые вероятные
+    // сперва самые вероятные 
     CHECK_SPEED(s,9600)
     CHECK_SPEED(s,19200)
     CHECK_SPEED(s,38400)
@@ -450,7 +450,7 @@ ComPort::Speed ComPort::getSpeed( const string& s )
     CHECK_SPEED(s,1800)
     CHECK_SPEED(s,2400)
     CHECK_SPEED(s,4800)
-
+    
     CHECK_SPEED(s,230400)
     CHECK_SPEED(s,460800)
     CHECK_SPEED(s,500000)

src/Communications/ComPort485F.cc

@@ -87,7 +87,7 @@ unsigned char ComPort485F::m_receiveByte( bool wait )
         gpio_low_set_value(gpio_num, 0);
     }
     if( rq.empty() )
-    {
+    {    
         int rc = 0;
         if( wait )
         {
@@ -100,17 +100,17 @@ unsigned char ComPort485F::m_receiveByte( bool wait )
             {
                 ioctl(fd, FIONREAD, &rc);
                 if( rc > 0 )
-                {
+                {            
                     rc = ::read(fd,tbuf,sizeof(tbuf));
                     if( rc > 0 )
                     {
-                        if( remove_echo(tbuf,rc) )
+                        if( remove_echo(tbuf,rc) ) 
                             break;
                     }
                 }
                 usleep(3000);
             }
-
+            
             if ( ptRecv.checkTime() )
                 rc = -1;
         }
@@ -132,7 +132,7 @@ unsigned char ComPort485F::m_receiveByte( bool wait )
             throw UniSetTypes::TimeOut();
     }
 
-
+        
     unsigned char x = rq.front();
     rq.pop();
     return x;
@@ -250,7 +250,7 @@ bool ComPort485F::remove_echo( unsigned char tb[], int len )
             rq.push(tb[i]);
     }
 
-    // возвращаем число оставшихся символов
+    // возвращаем число оставшихся символов    
     return wq.empty();
 }
 // --------------------------------------------------------------------------------
@@ -262,7 +262,7 @@ void ComPort485F::m_read( int tmsec )
     {
         ioctl(fd, FIONREAD, &rc);
         if( rc > 0 )
-        {
+        {            
             rc = ::read(fd,tbuf,sizeof(tbuf));
             if( rc > 0 )
             {

src/Communications/Modbus/ModbusHelpers.cc

@@ -50,7 +50,7 @@ ModbusAddr ModbusHelpers::autodetectSlave( ModbusRTUMaster* m,
             {
                 ReadOutputRetMessage ret = m->read03(a,reg,1);
             }
-            else
+            else 
                 throw mbException(erOperationFailed);
 
             return a;
@@ -65,7 +65,7 @@ ModbusAddr ModbusHelpers::autodetectSlave( ModbusRTUMaster* m,
         if( (beg == 0xff) || (end == 0xff) )
             break;
     }
-
+    
     throw TimeOut();
 }
 // -------------------------------------------------------------------------
@@ -109,7 +109,7 @@ ComPort::Speed ModbusHelpers::autodetectSpeed( ModbusRTUMaster* m, ModbusAddr sl
             {
                 ReadOutputRetMessage ret = m->read03(slave,reg,1);
             }
-            else
+            else 
                 throw mbException(erOperationFailed);
 
 
@@ -126,12 +126,12 @@ ComPort::Speed ModbusHelpers::autodetectSpeed( ModbusRTUMaster* m, ModbusAddr sl
         }
         catch(...){}
     }
-
+    
     m->setSpeed(cur);
 
     if( s!=ComPort::ComSpeed0 )
         return s;
-
+    
     throw TimeOut();
 }
 // -------------------------------------------------------------------------

src/Communications/Modbus/ModbusRTUMaster.cc

@@ -36,7 +36,7 @@ ModbusRTUMaster::ModbusRTUMaster( const string& dev, bool use485, bool tr_ctl ):
     port->setStopBits(ComPort::OneBit);
     port->setWaiting(true);
     port->setTimeout(replyTimeOut_ms);
-//    port->setBlocking(false);
+//    port->setBlocking(false); 
 }
 // -------------------------------------------------------------------------
 ModbusRTUMaster::ModbusRTUMaster( ComPort* com ):
@@ -52,12 +52,12 @@ ModbusRTUMaster::ModbusRTUMaster( ComPort* com ):
     port->setStopBits(ComPort::OneBit);
     port->setWaiting(true);
     port->setTimeout(replyTimeOut_ms);
-//    port->setBlocking(false);
+//    port->setBlocking(false); 
 }
 // -------------------------------------------------------------------------
 ModbusRTUMaster::~ModbusRTUMaster()
 {
-    if( myport )
+    if( myport ) 
         delete port;
 }
 // -------------------------------------------------------------------------

src/Communications/Modbus/ModbusRTUSlave.cc

@@ -38,7 +38,7 @@ ModbusRTUSlave::ModbusRTUSlave( const string& dev, bool use485, bool tr_ctl ):
     port->setStopBits(ComPort::OneBit);
     port->setWaiting(true);
     port->setTimeout(recvTimeOut_ms);
-//    port->setBlocking(false);
+//    port->setBlocking(false); 
 }
 
 // -------------------------------------------------------------------------
@@ -52,7 +52,7 @@ ModbusRTUSlave::ModbusRTUSlave( ComPort* com ):
     port->setStopBits(ComPort::OneBit);
     port->setWaiting(true);
     port->setTimeout(recvTimeOut_ms);
-//    port->setBlocking(false);
+//    port->setBlocking(false); 
 }
 
 // -------------------------------------------------------------------------
@@ -83,7 +83,7 @@ mbErrCode ModbusRTUSlave::receive( ModbusRTU::ModbusAddr addr, timeout_t timeout
             // то посылаем
             if( res < erInternalErrorCode )
             {
-                ErrorRetMessage em( buf.addr, buf.func, res );
+                ErrorRetMessage em( buf.addr, buf.func, res ); 
                 buf = em.transport_msg();
                 send(buf);
                 printProcessingTime();
@@ -95,7 +95,7 @@ mbErrCode ModbusRTUSlave::receive( ModbusRTU::ModbusAddr addr, timeout_t timeout
             return res;
         }
 
-        // если полученный пакет адресован
+        // если полученный пакет адресован 
         // не данному узлу (и не широковещательный)
         // то ждать следующий...
     }
@@ -112,7 +112,7 @@ ComPort::Speed ModbusRTUSlave::getSpeed()
 {
     if( port == NULL )
         return ComPort::ComSpeed0;
-
+    
     return port->getSpeed();
 }
 // -------------------------------------------------------------------------

src/Communications/Modbus/ModbusRTUSlaveSlot.cc

@@ -144,7 +144,7 @@ ModbusRTU::mbErrCode ModbusRTUSlaveSlot::remoteService( ModbusRTU::RemoteService
         return erOperationFailed;
 
     return slRemoteService(query,reply);
-}
+}                                    
 // -------------------------------------------------------------------------
 ModbusRTU::mbErrCode ModbusRTUSlaveSlot::fileTransfer( ModbusRTU::FileTransferMessage& query, 
                                     ModbusRTU::FileTransferRetMessage& reply )
@@ -153,7 +153,7 @@ ModbusRTU::mbErrCode ModbusRTUSlaveSlot::fileTransfer( ModbusRTU::FileTransferMe
         return erOperationFailed;
 
     return slFileTransfer(query,reply);
-}
+}                                    
 // -------------------------------------------------------------------------
 void ModbusRTUSlaveSlot::sigterm( int signo )
 {

src/Communications/Modbus/ModbusTCPCore.cc

@@ -16,15 +16,15 @@ int ModbusTCPCore::readNextData( ost::TCPStream* tcp,
         tcp->read(&c,sizeof(c));
         if( tcp->gcount() <= 0 )
             break;
-
+    
         qrecv.push( (unsigned char)(c) );
     }
-
+    
     return i;
 }
 // -------------------------------------------------------------------------
 int ModbusTCPCore::getNextData( unsigned char* buf, int len, 
-                                std::queue<unsigned char>& qrecv,
+                                std::queue<unsigned char>& qrecv, 
                                 ost::TCPStream* tcp )
 {
     if( !tcp || !tcp->isConnected() )
@@ -60,17 +60,17 @@ mbErrCode ModbusTCPCore::sendData( unsigned char* buf, int len, ost::TCPStream*
     {
         for( unsigned int i=0; i<len; i++ )
             (*tcp) << buf[i];
-
+        
         return erNoError;
     }
-    catch( ost::SockException& e )
+    catch( ost::SockException& e ) 
     {
 //        cerr << "(send): " << e.getString() << ": " << e.getSystemErrorString() << endl;
     }
     catch(...)
     {
 //        cerr << "(send): cath..." << endl;
-    }
+    }    
 
     return erHardwareError;
 }

src/Communications/Modbus/ModbusTCPServer.cc

@@ -75,7 +75,7 @@ bool ModbusTCPServer::waitQuery( ModbusRTU::ModbusAddr mbaddr, timeout_t msec )
     if( cancelled )
         return false;
 
-    try
+    try 
     {
         if( isPendingConnection(msec) )
         {
@@ -94,8 +94,8 @@ bool ModbusTCPServer::waitQuery( ModbusRTU::ModbusAddr mbaddr, timeout_t msec )
             s->connectWriteSingleOutput( sigc::mem_fun(this, &ModbusTCPServer::writeOutputSingleRegister) );
             s->connectMEIRDI( sigc::mem_fun(this, &ModbusTCPServer::read4314) );
             s->connectSetDateTime( sigc::mem_fun(this, &ModbusTCPServer::setDateTime) );
-            s->connectDiagnostics( sigc::mem_fun(this, &ModbusTCPServer::diagnostics) );
-            s->connectFileTransfer( sigc::mem_fun(this, &ModbusTCPServer::fileTransfer) );
+            s->connectDiagnostics( sigc::mem_fun(this, &ModbusTCPServer::diagnostics) );    
+            s->connectFileTransfer( sigc::mem_fun(this, &ModbusTCPServer::fileTransfer) );  
             s->connectJournalCommand( sigc::mem_fun(this, &ModbusTCPServer::journalCommand) );
             s->connectRemoteService( sigc::mem_fun(this, &ModbusTCPServer::remoteService) );
             s->connectFileTransfer( sigc::mem_fun(this, &ModbusTCPServer::fileTransfer) );
@@ -139,7 +139,7 @@ mbErrCode ModbusTCPServer::receive( ModbusRTU::ModbusAddr addr, timeout_t timeou
     assert(timeout);
 
     ptTimeout.reset();
-    try
+    try 
     {
         if( isPendingConnection(timeout) )
         {
@@ -185,7 +185,7 @@ mbErrCode ModbusTCPServer::receive( ModbusRTU::ModbusAddr addr, timeout_t timeou
                     // для режима игнорирования RTU-адреса
                     // просто подменяем его на то который пришёл
                     // чтобы проверка всегда была успешной...
-                    if( ignoreAddr )
+                    if( ignoreAddr ) 
                         addr = _addr;
                     else if( _addr != addr )
                     {
@@ -194,7 +194,7 @@ mbErrCode ModbusTCPServer::receive( ModbusRTU::ModbusAddr addr, timeout_t timeou
                         /*
                         res = erBadReplyNodeAddress;
                         tmProcessing.setTiming(replyTimeout_ms);
-                        ErrorRetMessage em( _addr, buf.func, res );
+                        ErrorRetMessage em( _addr, buf.func, res ); 
                         buf = em.transport_msg();
                         send(buf);
                         printProcessingTime();
@@ -212,7 +212,7 @@ mbErrCode ModbusTCPServer::receive( ModbusRTU::ModbusAddr addr, timeout_t timeou
                 {
                     if( res < erInternalErrorCode )
                     {
-                        ErrorRetMessage em( addr, buf.func, res );
+                        ErrorRetMessage em( addr, buf.func, res ); 
                         buf = em.transport_msg();
                         send(buf);
                         printProcessingTime();
@@ -305,7 +305,7 @@ mbErrCode ModbusTCPServer::tcp_processing( ost::TCPStream& tcp, ModbusTCP::MBAPH
     if( len<mhead.len )
     {
         if( dlog.is_info() )
-            dlog.info() << "(ModbusTCPServer::tcp_processing): len(" << (int)len
+            dlog.info() << "(ModbusTCPServer::tcp_processing): len(" << (int)len 
                     << ") < mhead.len(" << (int)mhead.len << ")" << endl;
 
         return erInvalidFormat;

src/Communications/Modbus/ModbusTCPServerSlot.cc

@@ -140,7 +140,7 @@ ModbusRTU::mbErrCode ModbusTCPServerSlot::remoteService( ModbusRTU::RemoteServic
     return slRemoteService(query,reply);
 }
 // -------------------------------------------------------------------------
-ModbusRTU::mbErrCode ModbusTCPServerSlot::fileTransfer( ModbusRTU::FileTransferMessage& query,
+ModbusRTU::mbErrCode ModbusTCPServerSlot::fileTransfer( ModbusRTU::FileTransferMessage& query, 
                                     ModbusRTU::FileTransferRetMessage& reply )
 {
     if( !slFileTransfer )

src/Communications/Modbus/ModbusTCPSession.cc

@@ -114,7 +114,7 @@ ModbusRTU::mbErrCode ModbusTCPSession::receive( ModbusRTU::ModbusAddr addr, time
             // для режима игнорирования RTU-адреса
             // просто подменяем его на то который пришёл
             // чтобы проверка всегда была успешной...
-            if( ignoreAddr )
+            if( ignoreAddr ) 
                 addr = _addr;
             else if( _addr != addr )
             {
@@ -136,7 +136,7 @@ ModbusRTU::mbErrCode ModbusTCPSession::receive( ModbusRTU::ModbusAddr addr, time
         {
             if( res < erInternalErrorCode )
             {
-                ErrorRetMessage em( addr, buf.func, res );
+                ErrorRetMessage em( addr, buf.func, res ); 
                 buf = em.transport_msg();
                 send(buf);
                 printProcessingTime();
@@ -219,7 +219,7 @@ mbErrCode ModbusTCPSession::tcp_processing( ost::TCPStream& tcp, ModbusTCP::MBAP
     if( len<mhead.len )
     {
         if( dlog.debugging(Debug::INFO) )
-            dlog[Debug::INFO] << peername << "(tcp_processing): len(" << (int)len
+            dlog[Debug::INFO] << peername << "(tcp_processing): len(" << (int)len 
                     << ") < mhead.len(" << (int)mhead.len << ")" << endl;
 
         return erInvalidFormat;
@@ -286,7 +286,7 @@ void ModbusTCPSession::terminate()
 //        ost::Thread::join();
 }
 // -------------------------------------------------------------------------
-mbErrCode ModbusTCPSession::readCoilStatus( ReadCoilMessage& query,
+mbErrCode ModbusTCPSession::readCoilStatus( ReadCoilMessage& query, 
                                                 ReadCoilRetMessage& reply )
 {
     if( !slReadCoil )
@@ -296,7 +296,7 @@ mbErrCode ModbusTCPSession::readCoilStatus( ReadCoilMessage& query,
 }
 
 // -------------------------------------------------------------------------
-mbErrCode ModbusTCPSession::readInputStatus( ReadInputStatusMessage& query,
+mbErrCode ModbusTCPSession::readInputStatus( ReadInputStatusMessage& query, 
                                                 ReadInputStatusRetMessage& reply )
 {
     if( !slReadInputStatus )
@@ -307,7 +307,7 @@ mbErrCode ModbusTCPSession::readInputStatus( ReadInputStatusMessage& query,
 
 // -------------------------------------------------------------------------
 
-mbErrCode ModbusTCPSession::readOutputRegisters( ReadOutputMessage& query,
+mbErrCode ModbusTCPSession::readOutputRegisters( ReadOutputMessage& query, 
                                                 ReadOutputRetMessage& reply )
 {
     if( !slReadOutputs )
@@ -317,7 +317,7 @@ mbErrCode ModbusTCPSession::readOutputRegisters( ReadOutputMessage& query,
 }
 
 // -------------------------------------------------------------------------
-mbErrCode ModbusTCPSession::readInputRegisters( ReadInputMessage& query,
+mbErrCode ModbusTCPSession::readInputRegisters( ReadInputMessage& query, 
                                                 ReadInputRetMessage& reply )
 {
     if( !slReadInputs )
@@ -327,7 +327,7 @@ mbErrCode ModbusTCPSession::readInputRegisters( ReadInputMessage& query,
 }
 
 // -------------------------------------------------------------------------
-mbErrCode ModbusTCPSession::forceMultipleCoils( ForceCoilsMessage& query,
+mbErrCode ModbusTCPSession::forceMultipleCoils( ForceCoilsMessage& query, 
                                                 ForceCoilsRetMessage& reply )
 {
     if( !slForceCoils )
@@ -338,7 +338,7 @@ mbErrCode ModbusTCPSession::forceMultipleCoils( ForceCoilsMessage& query,
 
 // -------------------------------------------------------------------------
 
-mbErrCode ModbusTCPSession::writeOutputRegisters( WriteOutputMessage& query,
+mbErrCode ModbusTCPSession::writeOutputRegisters( WriteOutputMessage& query, 
                                                 WriteOutputRetMessage& reply )
 {
     if( !slWriteOutputs )
@@ -348,7 +348,7 @@ mbErrCode ModbusTCPSession::writeOutputRegisters( WriteOutputMessage& query,
 }
 
 // -------------------------------------------------------------------------
-mbErrCode ModbusTCPSession::diagnostics( DiagnosticMessage& query,
+mbErrCode ModbusTCPSession::diagnostics( DiagnosticMessage& query, 
                                                 DiagnosticRetMessage& reply )
 {
     if( !slDiagnostics )
@@ -357,7 +357,7 @@ mbErrCode ModbusTCPSession::diagnostics( DiagnosticMessage& query,
     return slDiagnostics(query,reply);
 }
 // -------------------------------------------------------------------------
-ModbusRTU::mbErrCode ModbusTCPSession::read4314( ModbusRTU::MEIMessageRDI& query,
+ModbusRTU::mbErrCode ModbusTCPSession::read4314( ModbusRTU::MEIMessageRDI& query, 
                                         ModbusRTU::MEIMessageRetRDI& reply )
 {
     if( !slMEIRDI )
@@ -366,7 +366,7 @@ ModbusRTU::mbErrCode ModbusTCPSession::read4314( ModbusRTU::MEIMessageRDI& query
     return slMEIRDI(query,reply);
 }
 // -------------------------------------------------------------------------
-mbErrCode ModbusTCPSession::forceSingleCoil( ForceSingleCoilMessage& query,
+mbErrCode ModbusTCPSession::forceSingleCoil( ForceSingleCoilMessage& query, 
                                             ForceSingleCoilRetMessage& reply )
 {
     if( !slForceSingleCoil )
@@ -376,7 +376,7 @@ mbErrCode ModbusTCPSession::forceSingleCoil( ForceSingleCoilMessage& query,
 }
 
 // -------------------------------------------------------------------------
-mbErrCode ModbusTCPSession::writeOutputSingleRegister( WriteSingleOutputMessage& query,
+mbErrCode ModbusTCPSession::writeOutputSingleRegister( WriteSingleOutputMessage& query, 
                                                 WriteSingleOutputRetMessage& reply )
 {
     if( !slWriteSingleOutputs )
@@ -386,7 +386,7 @@ mbErrCode ModbusTCPSession::writeOutputSingleRegister( WriteSingleOutputMessage&
 }
 
 // -------------------------------------------------------------------------
-mbErrCode ModbusTCPSession::journalCommand( JournalCommandMessage& query,
+mbErrCode ModbusTCPSession::journalCommand( JournalCommandMessage& query, 
                                                 JournalCommandRetMessage& reply )
 {
     if( !slJournalCommand )
@@ -395,7 +395,7 @@ mbErrCode ModbusTCPSession::journalCommand( JournalCommandMessage& query,
     return slJournalCommand(query,reply);
 }
 // -------------------------------------------------------------------------
-ModbusRTU::mbErrCode ModbusTCPSession::setDateTime( ModbusRTU::SetDateTimeMessage& query,
+ModbusRTU::mbErrCode ModbusTCPSession::setDateTime( ModbusRTU::SetDateTimeMessage& query, 
                                     ModbusRTU::SetDateTimeRetMessage& reply )
 {
     if( !slSetDateTime )
@@ -404,7 +404,7 @@ ModbusRTU::mbErrCode ModbusTCPSession::setDateTime( ModbusRTU::SetDateTimeMessag
     return slSetDateTime(query,reply);
 }
 // -------------------------------------------------------------------------
-ModbusRTU::mbErrCode ModbusTCPSession::remoteService( ModbusRTU::RemoteServiceMessage& query,
+ModbusRTU::mbErrCode ModbusTCPSession::remoteService( ModbusRTU::RemoteServiceMessage& query, 
                                     ModbusRTU::RemoteServiceRetMessage& reply )
 {
     if( !slRemoteService )
@@ -413,7 +413,7 @@ ModbusRTU::mbErrCode ModbusTCPSession::remoteService( ModbusRTU::RemoteServiceMe
     return slRemoteService(query,reply);
 }
 // -------------------------------------------------------------------------
-ModbusRTU::mbErrCode ModbusTCPSession::fileTransfer( ModbusRTU::FileTransferMessage& query,
+ModbusRTU::mbErrCode ModbusTCPSession::fileTransfer( ModbusRTU::FileTransferMessage& query, 
                                     ModbusRTU::FileTransferRetMessage& reply )
 {
     if( !slFileTransfer )

src/Interfaces/UInterface.cc

@@ -115,7 +115,7 @@ void UInterface::initBackId( const UniSetTypes::ObjectId backid )
  * \exception IOBadParam - генерируется если указано неправильное имя датчика или секции
  * \exception IOTimeOut - генерируется если в течение времени timeout небыл получен ответ
 */
-long UInterface::getValue( const ObjectId id, const ObjectId node ) const
+long UInterface::getValue( const ObjectId id, const ObjectId node ) const 
     throw(IO_THROW_EXCEPTIONS)
 {
     if ( id == DefaultObjectId )
@@ -252,7 +252,7 @@ void UInterface::setUndefinedState( const IOController_i::SensorInfo& si, bool u
     catch(CORBA::NO_IMPLEMENT)
     {
         rcache.erase(si.id, si.node);
-        uwarn << set_err("UI(setUndefinedState): method no implement",si.id,si.node) << endl;
+        uwarn << set_err("UI(setUndefinedState): method no implement",si.id,si.node) << endl;    
     }
     catch(CORBA::OBJECT_NOT_EXIST)
     {
@@ -344,7 +344,7 @@ void UInterface::setValue( const ObjectId id, long value, const ObjectId node )
     throw UniSetTypes::TimeOut(set_err("UI(setValue): Timeout",id,node));
 }
 
-void UInterface::setValue( const ObjectId name, long value ) const
+void UInterface::setValue( const ObjectId name, long value ) const 
 {
     setValue(name, value, uconf->getLocalNode());
 }
@@ -884,7 +884,7 @@ ObjectPtr UInterface::resolve( const ObjectId rid , const ObjectId node, int tim
 }
 
 // -------------------------------------------------------------------------------------------
-void UInterface::send( const ObjectId name, const TransportMessage& msg, const ObjectId node )
+void UInterface::send( const ObjectId name, const TransportMessage& msg, const ObjectId node ) 
     throw(IO_THROW_EXCEPTIONS)
 {
     if ( name == DefaultObjectId )
@@ -1157,7 +1157,7 @@ string UInterface::set_err( const std::string& pre, const ObjectId id, const Obj
         nm = "UnknownName";
 
     ostringstream s;
-    s << pre << " (" << id << ":" << node <<")" << nm;
+    s << pre << " (" << id << ":" << node <<")" << nm; 
     return s.str();
 }
 // --------------------------------------------------------------------------------------------

src/ObjectRepository/IORFile.cc

@@ -19,7 +19,7 @@
  */
 // -----------------------------------------------------------------------------------------
 /*! 
-    \todo Добавить проверку на предельный номер id
+    \todo Добавить проверку на предельный номер id 
 */
 // -----------------------------------------------------------------------------------------
 #include <sstream>

src/ObjectRepository/ORepHelpers.cc

@@ -35,12 +35,12 @@ using namespace std;
 
 namespace ORepHelpers
 {
-
+    
 
 // --------------------------------------------------------------------------
     /*!
-     *    \param cname - полное имя контекста ссылку на который, возвратит функция.
-     *    \param argc, argv  - параметры инициализации ORB
+     *    \param cname - полное имя контекста ссылку на который, возвратит функция. 
+     *    \param argc, argv  - параметры инициализации ORB      
     */
     CosNaming::NamingContext_ptr getContext(const string& cname, int argc, const char* const* argv, const string& nsName ) throw(ORepFailed)
     {
@@ -192,7 +192,7 @@ namespace ORepHelpers
     // ---------------------------------------------------------------------------------------------------------------
     /*!
      *    \param fname - полное имя включающее в себя путь ("Root/Section1/name|Node:Alias")
-     *    \param brk  - используемый символ разделитель
+     *    \param brk  - используемый символ разделитель      
     */
     const string getShortName( const string& fname, const std::string& brk )
     {
@@ -206,7 +206,7 @@ namespace ORepHelpers
     // ---------------------------------------------------------------------------------------------------------------
     /*!
      *    \param fullName - полное имя включающее в себя путь
-     *    \param brk  - используемый символ разделитель
+     *    \param brk  - используемый символ разделитель      
      *  \note Функция возвращает путь без последнего символа разделителя ("Root/Section1/name" -> "Root/Section1")
     */
     const string getSectionName( const string& fullName, const std::string& brk )

src/ObjectRepository/ObjectIndex.cc

@@ -20,7 +20,7 @@
  */
 // -----------------------------------------------------------------------------------------
 /*! 
-    \todo Добавить проверку на предельный номер id
+    \todo Добавить проверку на предельный номер id 
 */
 // -----------------------------------------------------------------------------------------
 #include "ObjectIndex.h"

src/ObjectRepository/ObjectIndex_Array.cc

@@ -20,7 +20,7 @@
  */
 // -----------------------------------------------------------------------------------------
 /*! 
-    \todo Добавить проверку на предельный номер id
+    \todo Добавить проверку на предельный номер id 
 */
 // -----------------------------------------------------------------------------------------
 #include <iomanip>
@@ -56,7 +56,7 @@ ObjectId ObjectIndex_Array::getIdByName( const string& name )
     auto it = mok.find(name);
     if( it != mok.end() )
         return it->second;
-
+        
     return DefaultObjectId;
 }
 
@@ -67,9 +67,9 @@ string ObjectIndex_Array::getMapName( const ObjectId id )
         return objectInfo[id].repName;
 
     return "";
-//    throw OutOfRange("ObjectIndex_Array::getMapName OutOfRange");
+//    throw OutOfRange("ObjectIndex_Array::getMapName OutOfRange");                
 }
-// -----------------------------------------------------------------------------------------
+// -----------------------------------------------------------------------------------------        
 string ObjectIndex_Array::getTextName( const ObjectId id )
 {
     if( id!=UniSetTypes::DefaultObjectId && id>=0 && id<maxId )
@@ -94,7 +94,7 @@ std::ostream& ObjectIndex_Array::printMap( std::ostream& os )
 
         assert (i==objectInfo[i].id);
 
-        os  << setw(5) << objectInfo[i].id << "  "
+        os  << setw(5) << objectInfo[i].id << "  " 
             << setw(45) << conf->oind->getBaseName(objectInfo[i].repName)
             << "  " << objectInfo[i].textName << endl;
     }

src/ObjectRepository/ObjectIndex_XML.cc

@@ -88,9 +88,9 @@ std::ostream& ObjectIndex_XML::printMap( std::ostream& os )
         if( it->repName == NULL )
             continue;
 
-        os  << setw(5) << it->id << "  "
-//            << setw(45) << ORepHelpers::getShortName(it->repName,'/')
-            << setw(45) << it->repName
+        os  << setw(5) << it->id << "  " 
+//            << setw(45) << ORepHelpers::getShortName(it->repName,'/') 
+            << setw(45) << it->repName 
             << "  " << it->textName << endl;
     }
 
@@ -107,8 +107,8 @@ void ObjectIndex_XML::build(UniXML& xml)
     ind = read_section(xml,"controllers",ind);
     ind = read_section(xml,"services",ind);
     ind = read_nodes(xml,"nodes",ind);
-
-    //
+    
+    // 
     omap.resize(ind);
 //    omap[ind].repName=NULL;
 //    omap[ind].textName=NULL;
@@ -255,7 +255,7 @@ unsigned int ObjectIndex_XML::read_nodes( UniXML& xml, const std::string& sec, u
         strcpy( omap[ind].textName, textname.c_str() );
 
         omap[ind].data = (void*)(xmlNode*)(it);
-        //
+        // 
         mok[omap[ind].repName] = ind;
 
 //        cout << "read: " << "(" << ind << ") " << omap[ind].repName << "\t" << omap[ind].textName << endl;

src/ObjectRepository/ObjectIndex_idXML.cc

@@ -45,7 +45,7 @@ string ObjectIndex_idXML::getMapName( const ObjectId id )
 
     return "";
 }
-// -----------------------------------------------------------------------------------------
+// -----------------------------------------------------------------------------------------        
 string ObjectIndex_idXML::getTextName( const ObjectId id )
 {
     auto it = omap.find(id);
@@ -68,9 +68,9 @@ std::ostream& ObjectIndex_idXML::printMap( std::ostream& os )
         if( it->second.repName == NULL )
             continue;
 
-        os  << setw(5) << it->second.id << "  "
-//            << setw(45) << ORepHelpers::getShortName(it->repName,'/')
-            << setw(45) << it->second.repName
+        os  << setw(5) << it->second.id << "  " 
+//            << setw(45) << ORepHelpers::getShortName(it->repName,'/') 
+            << setw(45) << it->second.repName 
             << "  " << it->second.textName << endl;
     }
 
@@ -136,7 +136,7 @@ void ObjectIndex_idXML::read_section( UniXML& xml, const std::string& sec )
         if( inf.id <= 0 )
         {
             ostringstream msg;
-            msg << "(ObjectIndex_idXML::build): НЕ УКАЗАН id для " << it.getProp("name")
+            msg << "(ObjectIndex_idXML::build): НЕ УКАЗАН id для " << it.getProp("name") 
                 << " секция " << sec;
             throw NameNotFound(msg.str());
         }

src/ObjectRepository/ObjectRepository.cc

@@ -162,7 +162,7 @@ void ObjectRepository::registration(const string& name, const ObjectPtr oRef, co
  *  \note При этом надо иметь ввиду, что задается полное имя объекта.
  *    Пример: registration("Root/SensorSection/sens1", oRef);
  *    \param fullName - полное имя регистрируемого объекта (т.е. включающее в себя имя секции)
- *    \param oRef - ссылка на объект
+ *    \param oRef - ссылка на объект 
  *  \exception ORepFailed - генерируется если произошла ошибка при регистрации
  *  \sa registration(const string name, const ObjectPtr oRef, const string section)
 */
@@ -325,7 +325,7 @@ bool ObjectRepository::list(const string& section, ListObjectName *ls, unsigned
     try
     {
         CORBA::ORB_var orb = uconf->getORB();
-        ctx = ORepHelpers::getContext(orb, section, nsName);
+        ctx = ORepHelpers::getContext(orb, section, nsName);    
     }
     catch(ORepFailed)
     {
@@ -358,7 +358,7 @@ bool ObjectRepository::list(const string& section, ListObjectName *ls, unsigned
     for( unsigned int i=0; i<how_many;i++)
     {
         switch( type )
-        {
+        { 
             case ObjectRef:
             {
                 if(bl[i].binding_type == CosNaming::nobject)

src/ObjectRepository/ObjectRepositoryFactory.cc

@@ -121,7 +121,7 @@ bool ObjectRepositoryFactory::createRootSection(const string& name)
 // -----------------------------------------------------------------------------------------------------------
 bool ObjectRepositoryFactory::createContext(const char *cname, CosNaming::NamingContext_ptr ctx)
 {
-
+    
     CosNaming::Name_var nc = omniURI::stringToName(cname);
     try
     {
@@ -133,12 +133,12 @@ bool ObjectRepositoryFactory::createContext(const char *cname, CosNaming::Naming
     catch(const CosNaming::NamingContext::AlreadyBound &ab)
     {
 //        ctx->resolve(nc);
-        ulogrep << "ORepFactory(createContext): context "<< cname << " уже есть"<< endl;
+        ulogrep << "ORepFactory(createContext): context "<< cname << " уже есть"<< endl;        
         return true;
     }
     catch(CosNaming::NamingContext::NotFound)
     {
-        ulogrep << "ORepFactory(createContext): NotFound "<< cname << endl;
+        ulogrep << "ORepFactory(createContext): NotFound "<< cname << endl;        
         throw NameNotFound();
     }
     catch(const CosNaming::NamingContext::InvalidName &nf)
@@ -147,7 +147,7 @@ bool ObjectRepositoryFactory::createContext(const char *cname, CosNaming::Naming
     }
     catch(const CosNaming::NamingContext::CannotProceed &cp)
     {
-        uwarn << "ORepFactory(createContext): catch CannotProced "
+        uwarn << "ORepFactory(createContext): catch CannotProced " 
                 << cname << " bad part="
                 << omniURI::nameToString(cp.rest_of_name);
         throw NameNotFound();
@@ -212,7 +212,7 @@ bool ObjectRepositoryFactory::removeSection(const string& fullName, bool recursi
     unsigned int how_many = 1000;
     CosNaming::NamingContext_var ctx;
     try
-    {
+    {    
         int argc(uconf->getArgc());
         const char * const* argv(uconf->getArgv());
         ctx = ORepHelpers::getContext(fullName, argc, argv, nsName);
@@ -231,11 +231,11 @@ bool ObjectRepositoryFactory::removeSection(const string& fullName, bool recursi
     if( how_many>bl->length() )
         how_many = bl->length();
 
-    bool rem = true; // удалять или нет
-
+    bool rem = true; // удалять или нет 
+    
     for(unsigned int i=0; i<how_many;i++)
     {
-
+    
         if(    bl[i].binding_type == CosNaming::nobject)
           {
 //            cout <<"удаляем "<< omniURI::nameToString(bl[i].binding_name) << endl;
@@ -317,8 +317,8 @@ bool ObjectRepositoryFactory::renameSection( const string& newFName, const strin
     {
         int argc(uconf->getArgc());
         const char * const* argv(uconf->getArgv());
-        CosNaming::NamingContext_var in_ctx = ORepHelpers::getContext(in_sec, argc, argv, nsName);
-        CosNaming::NamingContext_var ctx = ORepHelpers::getContext(oldFName, argc, argv, nsName);
+        CosNaming::NamingContext_var in_ctx = ORepHelpers::getContext(in_sec, argc, argv, nsName);    
+        CosNaming::NamingContext_var ctx = ORepHelpers::getContext(oldFName, argc, argv, nsName);    
 
         // заменит контекст newFName если он существовал
         in_ctx->rebind_context(ctxNewName, ctx);

src/ObjectRepository/PassiveObject.cc

@@ -42,7 +42,7 @@ PassiveObject::PassiveObject( UniSetTypes::ObjectId id ):
     id(id)
 {
     string myfullname = conf->oind->getNameById(id);
-    myname = ORepHelpers::getShortName(myfullname.c_str());
+    myname = ORepHelpers::getShortName(myfullname.c_str()); 
 }
 
 PassiveObject::PassiveObject( ObjectId id, ProxyManager* mngr ):
@@ -116,7 +116,7 @@ void PassiveObject::processingMessage( UniSetTypes::VoidMessage *msg )
     {
         uwarn << myname << "(processingMessage): CORBA::Exception: " << ex._name() << endl;
     }
-    catch( omniORB::fatalException& fe )
+    catch( omniORB::fatalException& fe ) 
     {
         if( ulog.is_crit() )
         {

src/ObjectRepository/ProxyManager.cc

@@ -81,7 +81,7 @@ bool ProxyManager::activateObject()
             {
                 try
                 {
-                    uinfo << myname << "(registered): попытка "
+                    uinfo << myname << "(registered): попытка " 
                           << i+1 << " регистриую (id=" << it.first << ") "
                           << " (pname=" << it.second->getName() << ") "
                           << conf->oind->getNameById(it.first) << endl;
@@ -144,7 +144,7 @@ void ProxyManager::processingMessage( UniSetTypes::VoidMessage *msg )
                 auto it = omap.find(msg->consumer);
                 if( it!=omap.end() )
                     it->second->processingMessage(msg);
-                else
+                else 
                     ucrit << myname << "(processingMessage): не найден объект "
                         << " consumer= " << msg->consumer << endl;
             }

src/ObjectRepository/UniSetActivator.cc

@@ -233,7 +233,7 @@ void UniSetActivator::run(bool thread)
         int ret = orbthr->start();
         if( ret !=0 )
         {
-            ucrit << myname << "(run):  НЕ СМОГЛИ СОЗДАТЬ ORB-поток"<<endl;
+            ucrit << myname << "(run):  НЕ СМОГЛИ СОЗДАТЬ ORB-поток"<<endl;    
             throw SystemError("(UniSetActivator::run): CREATE ORB THREAD FAILED");
         }
     }

src/ObjectRepository/UniSetManager.cc

@@ -201,7 +201,7 @@ bool UniSetManager::removeObject( UniSetObject* obj )
 }
 
 // ------------------------------------------------------------------------------------------
-/*!
+/*! 
  *    Функция работы со списком менеджеров
 */
 void UniSetManager::managers( OManagerCommand cmd )
@@ -264,7 +264,7 @@ void UniSetManager::managers( OManagerCommand cmd )
 */
 void UniSetManager::objects(OManagerCommand cmd)
 {
-    uinfo << myname <<"(objects): olist.size="
+    uinfo << myname <<"(objects): olist.size=" 
                         << olist.size() << " cmd=" << cmd  << endl;
     {    //lock
         uniset_rwmutex_rlock lock(olistMutex);
@@ -306,11 +306,11 @@ void UniSetManager::objects(OManagerCommand cmd)
             }
             catch( CORBA::Exception& ex )
             {
-                ucrit << myname << "(objects): Caught CORBA::Exception. "
+                ucrit << myname << "(objects): Caught CORBA::Exception. " 
                       << ex._name()
                       << " (" << li->getName() << ")" << endl;
             }
-            catch( omniORB::fatalException& fe )
+            catch( omniORB::fatalException& fe ) 
             {
                ucrit << myname << "(objects): Caught omniORB::fatalException:" << endl;
                ucrit << myname << "(objects): file: " << fe.file()
@@ -387,9 +387,9 @@ bool UniSetManager::addManager( UniSetManager *child )
              mlist.push_back( child );
              uinfo << myname << ": добавляем менеджер "<< child->getName()<< endl;
         }
-        else
+        else 
             uwarn << myname << ": попытка повторного добавления объекта "<< child->getName() << endl;
-    } // unlock
+    } // unlock 
 
     return true;
 }

src/ObjectRepository/UniSetManager_LT.cc

@@ -20,7 +20,7 @@
 /*! \file
  *  \author Pavel Vainerman
 */
-// --------------------------------------------------------------------------
+// -------------------------------------------------------------------------- 
 #include "Exceptions.h"
 #include "UniSetManager_LT.h"
 #include "Debug.h"
@@ -37,20 +37,20 @@ sleepTime(UniSetTimer::WaitUpTime)
 }
 // ------------------------------------------------------------------------------------------
 UniSetManager_LT::UniSetManager_LT():
-sleepTime(UniSetTimer::WaitUpTime)
+sleepTime(UniSetTimer::WaitUpTime) 
 {
 }
 
 // ------------------------------------------------------------------------------------------
-UniSetManager_LT::~UniSetManager_LT()
+UniSetManager_LT::~UniSetManager_LT() 
 {
 }
 // ------------------------------------------------------------------------------------------
 void UniSetManager_LT::callback()
 {
-    // При реализации с использованием waitMessage() каждый раз при вызове askTimer() необходимо
-    // проверять возвращаемое значение на UniSetTimers::WaitUpTime и вызывать termWaiting(),
-    // чтобы избежать ситуации, когда процесс до заказа таймера 'спал'(в функции waitMessage()) и после
+    // При реализации с использованием waitMessage() каждый раз при вызове askTimer() необходимо 
+    // проверять возвращаемое значение на UniSetTimers::WaitUpTime и вызывать termWaiting(), 
+    // чтобы избежать ситуации, когда процесс до заказа таймера 'спал'(в функции waitMessage()) и после 
     // заказа продолжит спать(т.е. обработчик вызван не будет)...
     try
     {

src/ObjectRepository/UniSetObject.cc

@@ -40,7 +40,7 @@
 using namespace std;
 using namespace UniSetTypes;
 
-#define CREATE_TIMER    new ThrPassiveTimer();
+#define CREATE_TIMER    new ThrPassiveTimer();     
 // new PassiveSysTimer();
 
 // ------------------------------------------------------------------------------------------
@@ -188,7 +188,7 @@ void UniSetObject::setID( UniSetTypes::ObjectId id )
         throw ObjectNameAlready("ObjectId already set(setID)");
 
     string myfullname = ui.getNameById(id);
-    myname = ORepHelpers::getShortName(myfullname.c_str());
+    myname = ORepHelpers::getShortName(myfullname.c_str()); 
     section = ORepHelpers::getSectionName(myfullname.c_str());
     myid = id;
     ui.initBackId(myid);
@@ -253,13 +253,13 @@ struct MsgInfo
        inline bool operator < ( const MsgInfo& mi ) const
     {
         if( type != mi.type )
-            return type < mi.type;
+            return type < mi.type; 
 
         if( id != mi.id )
             return id < mi.id;
 
         if( node != mi.node )
-            return node < mi.node;
+            return node < mi.node; 
 
         if( tm.tv_sec != mi.tm.tv_sec )
             return tm.tv_sec < mi.tm.tv_sec;
@@ -282,7 +282,7 @@ struct CInfo
      confirm(0)
     {
     }
-
+    
     CInfo( ConfirmMessage& cm ):
         sensor_id(cm.sensor_id),
         value(cm.value),
@@ -359,15 +359,15 @@ void UniSetObject::registered()
             catch( ObjectNameAlready& al )
             {
 /*! 
-    \warning По умолчанию объекты должны быть уникальны! Поэтому если идёт попытка повторной регистрации.
-    Мы чистим существующую ссылку и заменяем её на новую.
+    \warning По умолчанию объекты должны быть уникальны! Поэтому если идёт попытка повторной регистрации. 
+    Мы чистим существующую ссылку и заменяем её на новую.    
     Это сделано для более надежной работы, иначе может получится, что если объект перед завершением
     не очистил за собой ссылку(не разрегистрировался), то больше он никогда не сможет вновь зарегистрироваться.
     Т.к. \b надёжной функции проверки "жив" ли объект пока нет...
     (так бы можно было проверить и если "не жив", то смело заменять ссылку на новую). Но существует обратная сторона:
-    если заменяемый объект "жив" и завершит свою работу, то он может почистить за собой ссылку и это тогда наш(новый)
+    если заменяемый объект "жив" и завершит свою работу, то он может почистить за собой ссылку и это тогда наш(новый) 
     объект станет недоступен другим, а знать об этом не будет!!!
-
+    
 */
                 ucrit << myname << "(registered): replace object (ObjectNameAlready)" << endl;
                 reg = true;
@@ -578,8 +578,8 @@ void UniSetObject::cleanMsgQueue( MessagesQueue& q )
             q.push(v);
     }
 
-    ucrit << myname
-        << "(cleanMsgQueue): ******* result size of queue: "
+    ucrit << myname 
+        << "(cleanMsgQueue): ******* result size of queue: " 
         << q.size()
         << " < " << getMaxSizeOfMessageQueue() << endl;
 
@@ -590,8 +590,8 @@ void UniSetObject::cleanMsgQueue( MessagesQueue& q )
 
         for( unsigned int i=0; i<getMaxCountRemoveOfMessage(); i++ )
         {
-            q.top();
-            q.pop();
+            q.top(); 
+            q.pop(); 
             if( q.empty() )
                 break;
         }
@@ -627,7 +627,7 @@ bool UniSetObject::deactivate()
     { // lock
         uniset_rwmutex_wrlock mlk(qmutex);
         while( !queueMsg.empty() )
-            queueMsg.pop();
+            queueMsg.pop(); 
     }
 
     try
@@ -700,8 +700,8 @@ bool UniSetObject::activate()
     }
     else
     {
-        // А если myid==UniSetTypes::DefaultObjectId
-        // то myname = noname. ВСЕГДА!
+        // А если myid==UniSetTypes::DefaultObjectId 
+        // то myname = noname. ВСЕГДА! 
         if( myid == UniSetTypes::DefaultObjectId )
         {
             ucrit << myname << "(activate): Не задан ID!!! activate failure..." << endl;
@@ -736,10 +736,10 @@ bool UniSetObject::activate()
         thr = new ThreadCreator<UniSetObject>(this, &UniSetObject::work);
         thr->start();
     }
-    else
+    else 
     {
-        uinfo << myname << ": ?? не задан ObjectId...("
-              << "myid=" << myid << " threadcreate=" << threadcreate
+        uinfo << myname << ": ?? не задан ObjectId...(" 
+              << "myid=" << myid << " threadcreate=" << threadcreate 
               << ")" << endl;
         thread(false);
     }
@@ -806,7 +806,7 @@ void UniSetObject::processingMessage( UniSetTypes::VoidMessage *msg )
     {
         uwarn << myname << "(processingMessage): CORBA::Exception: " << ex._name() << endl;
     }
-    catch( omniORB::fatalException& fe )
+    catch( omniORB::fatalException& fe ) 
     {
         if( ulog.is_crit() )
         {
@@ -831,26 +831,26 @@ UniSetTypes::SimpleInfo* UniSetObject::getInfo()
     info << "tid=" << setw(10);
     if( threadcreate )
     {
-        if(thr)
+        if(thr)    
         {
             msgpid = thr->getId();    // заодно(на всякий) обновим и внутреннюю информацию
-            info << msgpid;
+            info << msgpid;  
         }
         else
             info << "не запущен";
     }
     else
-        info << "откл.";
-
+        info << "откл.";  
+    
     info << "\tcount=" << countMessages();
     info << "\tmaxMsg=" << stMaxQueueMessages;
     info << "\tqFull("<< SizeOfMessageQueue << ")=" << stCountOfQueueFull;
 //    info << "\n";
-
+    
     SimpleInfo* res = new SimpleInfo();
     res->info     =  info.str().c_str(); // CORBA::string_dup(info.str().c_str());
     res->id     =  myid;
-
+    
     return res; // ._retn();
 }
 // ------------------------------------------------------------------------------------------

src/ObjectRepository/UniSetObject_LT.cc

@@ -48,12 +48,12 @@ UniSetObject_LT::~UniSetObject_LT()
 // ------------------------------------------------------------------------------------------
 void UniSetObject_LT::callback()
 {
-    // При реализации с использованием waitMessage() каждый раз при вызове askTimer() необходимо
-    // проверять возвращаемое значение на UniSetTimers::WaitUpTime и вызывать termWaiting(),
-    // чтобы избежать ситуации, когда процесс до заказа таймера 'спал'(в функции waitMessage()) и после
+    // При реализации с использованием waitMessage() каждый раз при вызове askTimer() необходимо 
+    // проверять возвращаемое значение на UniSetTimers::WaitUpTime и вызывать termWaiting(), 
+    // чтобы избежать ситуации, когда процесс до заказа таймера 'спал'(в функции waitMessage()) и после 
     // заказа продолжит спать(т.е. обработчик вызван не будет)...
     try
-    {
+    {    
         if( waitMessage(msg, sleepTime) )
             processingMessage(&msg);
 

src/ObjectRepository/UniSetTypes.cc

@@ -292,7 +292,7 @@ std::list<UniSetTypes::ParamSInfo> UniSetTypes::getSInfoList( const string& str,
 
         res.push_back(item);
     }
-
+    
     return res;
 }
 // --------------------------------------------------------------------------------------

src/Processes/IOController.cc

@@ -144,7 +144,7 @@ long IOController::localGetValue( IOController::IOStateList::iterator& li, const
 
     // -------------
     ostringstream err;
-    err << myname << "(localGetValue): Not found sensor (" << sid << ") "
+    err << myname << "(localGetValue): Not found sensor (" << sid << ") " 
         << conf->oind->getNameById(sid);
 
     uinfo << err.str() << endl;
@@ -157,7 +157,7 @@ void IOController::setUndefinedState( UniSetTypes::ObjectId sid, CORBA::Boolean
     localSetUndefinedState( li,undefined, sid );
 }
 // -----------------------------------------------------------------------------
-void IOController::localSetUndefinedState( IOStateList::iterator& li,
+void IOController::localSetUndefinedState( IOStateList::iterator& li, 
                                             bool undefined, const UniSetTypes::ObjectId sid )
 {
     // сохранение текущего состояния
@@ -241,7 +241,7 @@ void IOController::setValue( UniSetTypes::ObjectId sid, CORBA::Long value, UniSe
 }
 // ------------------------------------------------------------------------------------------
 void IOController::localSetValue( IOController::IOStateList::iterator& li,
-                                  UniSetTypes::ObjectId sid,
+                                  UniSetTypes::ObjectId sid, 
                                   CORBA::Long value, UniSetTypes::ObjectId sup_id )
 {
     if( sup_id == UniSetTypes::DefaultObjectId )
@@ -252,7 +252,7 @@ void IOController::localSetValue( IOController::IOStateList::iterator& li,
         li = ioList.find(sid);
 
     if( li==ioList.end() )
-    {
+    { 
         ostringstream err;
         err << myname << "(localSaveValue): Unknown sensor (" << sid << ")"
             << "name: " << conf->oind->getNameById(sid);
@@ -351,7 +351,7 @@ void IOController::ioRegistration( USensorInfo&& ainf, bool force )
             if( li!=ioList.end() )
             {
                 ostringstream err;
-                err << "Попытка повторной регистрации датчика("<< ainf.si.id << "). имя: "
+                err << "Попытка повторной регистрации датчика("<< ainf.si.id << "). имя: " 
                     << conf->oind->getNameById(ainf.si.id);
                 throw ObjectNameAlready(err.str().c_str());
             }
@@ -378,8 +378,8 @@ void IOController::ioRegistration( USensorInfo&& ainf, bool force )
         {
             try
             {
-                uinfo << myname
-                        << "(ioRegistration): регистрирую "
+                uinfo << myname 
+                        << "(ioRegistration): регистрирую " 
                         << conf->oind->getNameById(ainf.si.id) << endl;
 
                 ui.registered( ainf.si.id, getRef(), true );
@@ -442,7 +442,7 @@ void IOController::dumpToDB()
 
     {    // lock
 //        uniset_mutex_lock lock(ioMutex, 100);
-        for( auto li = ioList.begin(); li!=ioList.end(); ++li )
+        for( auto li = ioList.begin(); li!=ioList.end(); ++li ) 
         {
             uniset_rwmutex_rlock lock(li->second.val_lock);
             SensorMessage sm;
@@ -458,19 +458,19 @@ void IOController::dumpToDB()
             if ( !li->second.dbignore )
                 logging(sm);
         }
-    }    // unlock
+    }    // unlock 
 }
 // --------------------------------------------------------------------------------------------------------------
 IOController_i::SensorInfoSeq* IOController::getSensorsMap()
 {
     // ЗА ОСВОБОЖДЕНИЕ ПАМЯТИ ОТВЕЧАЕТ КЛИЕНТ!!!!!!
     // поэтому ему лучше пользоваться при получении _var-классом
-    IOController_i::SensorInfoSeq* res = new IOController_i::SensorInfoSeq();
+    IOController_i::SensorInfoSeq* res = new IOController_i::SensorInfoSeq();    
     res->length( ioList.size());
 
     unsigned int i=0;
     for( auto &it: ioList )
-    {
+    {    
         uniset_rwmutex_rlock lock(it.second.val_lock);
         (*res)[i] = it.second;
         i++;
@@ -499,7 +499,7 @@ IOController_i::SensorIOInfo IOController::getSensorIOInfo( const UniSetTypes::O
 
     // -------------
     ostringstream err;
-    err << myname << "(getSensorIOInfo): Unknown sensor (" << sid << ")"
+    err << myname << "(getSensorIOInfo): Unknown sensor (" << sid << ")" 
         << conf->oind->getNameById(sid);
 
     uinfo << err.str() << endl;
@@ -513,7 +513,7 @@ CORBA::Long IOController::getRawValue( UniSetTypes::ObjectId sid )
     if( it==ioList.end() )
     {
         ostringstream err;
-        err << myname << "(getRawValue): Unknown analog sensor (" << sid << ")"
+        err << myname << "(getRawValue): Unknown analog sensor (" << sid << ")" 
             << conf->oind->getNameById(sid);
         throw IOController_i::NameNotFound(err.str().c_str());
     }
@@ -526,14 +526,14 @@ CORBA::Long IOController::getRawValue( UniSetTypes::ObjectId sid )
         if( it->second.type == UniversalIO::AI )
             return UniSetTypes::lcalibrate(it->second.value,ci.minRaw,ci.maxRaw,ci.minCal,ci.maxCal,true);
 
-        if( it->second.type == UniversalIO::AO )
+        if( it->second.type == UniversalIO::AO ) 
             return UniSetTypes::lcalibrate(it->second.value,ci.minCal,ci.maxCal,ci.minRaw,ci.maxRaw,true);
     }
 
     return it->second.value;
 }
 // --------------------------------------------------------------------------------------------------------------
-void IOController::calibrate( UniSetTypes::ObjectId sid,
+void IOController::calibrate( UniSetTypes::ObjectId sid, 
                                 const IOController_i::CalibrateInfo& ci,
                                 UniSetTypes::ObjectId adminId )
 {
@@ -541,7 +541,7 @@ void IOController::calibrate( UniSetTypes::ObjectId sid,
     if( it==ioList.end() )
     {
         ostringstream err;
-        err << myname << "(calibrate): Unknown analog sensor (" << sid << ")"
+        err << myname << "(calibrate): Unknown analog sensor (" << sid << ")" 
             << conf->oind->getNameById(sid);
         throw IOController_i::NameNotFound(err.str().c_str());
     }
@@ -557,7 +557,7 @@ IOController_i::CalibrateInfo IOController::getCalibrateInfo( UniSetTypes::Objec
     if( it==ioList.end() )
     {
         ostringstream err;
-        err << myname << "(calibrate): Unknown analog sensor (" << sid << ")"
+        err << myname << "(calibrate): Unknown analog sensor (" << sid << ")" 
             << conf->oind->getNameById(sid);
         throw IOController_i::NameNotFound(err.str().c_str());
     }
@@ -579,7 +579,7 @@ IOController::USensorInfo::USensorInfo(IOController_i::SensorIOInfo* ai):
     any(0)
 {}
 
-IOController::USensorInfo&
+IOController::USensorInfo& 
             IOController::USensorInfo::operator=(IOController_i::SensorIOInfo& r)
 {
     (*this) = r;
@@ -587,16 +587,16 @@ IOController::USensorInfo&
     return *this;
 }
 
-IOController::USensorInfo&
+IOController::USensorInfo& 
                 IOController::USensorInfo::operator=(IOController_i::SensorIOInfo* r)
 {
     (*this) = (*r);
 //    any=0;
-
+    
     return *this;
 }
 
-const IOController::USensorInfo&
+const IOController::USensorInfo& 
                 IOController::USensorInfo::operator=(const IOController_i::SensorIOInfo& r)
 {
     (*this) = r;
@@ -605,7 +605,7 @@ const IOController::USensorInfo&
 }
 
 // ----------------------------------------------------------------------------------------
-bool IOController::checkIOFilters( const USensorInfo& ai, CORBA::Long& newvalue,
+bool IOController::checkIOFilters( const USensorInfo& ai, CORBA::Long& newvalue, 
                                     UniSetTypes::ObjectId sup_id )
 {
     for( auto &it: iofilters )
@@ -716,7 +716,7 @@ IOController_i::ShortIOInfo IOController::getChangedTime( UniSetTypes::ObjectId
 
     // -------------
     ostringstream err;
-    err << myname << "(getChangedTime): вход(выход) с именем "
+    err << myname << "(getChangedTime): вход(выход) с именем " 
         << conf->oind->getNameById(sid) << " не найден";
 
 	uinfo << err.str() << endl;
@@ -752,7 +752,7 @@ IOController::ChangeSignal IOController::signal_change_value( UniSetTypes::Objec
     if( it==ioList.end() )
     {
         ostringstream err;
-        err << myname << "(signal_change_value): вход(выход) с именем "
+        err << myname << "(signal_change_value): вход(выход) с именем " 
             << conf->oind->getNameById(sid) << " не найден";
 
         uinfo << err.str() << endl;
@@ -774,7 +774,7 @@ IOController::ChangeUndefinedStateSignal IOController::signal_change_undefined_s
     if( it==ioList.end() )
     {
         ostringstream err;
-        err << myname << "(signal_change_undefine): вход(выход) с именем "
+        err << myname << "(signal_change_undefine): вход(выход) с именем " 
             << conf->oind->getNameById(sid) << " не найден";
 
         uinfo << err.str() << endl;

src/Processes/IONotifyController_LT.cc

@@ -49,12 +49,12 @@ IONotifyController_LT::~IONotifyController_LT()
 // ------------------------------------------------------------------------------------------
 void IONotifyController_LT::callback()
 {
-    // При реализации с использованием waitMessage() каждый раз при вызове askTimer() необходимо
-    // проверять возвращаемое значение на UniSetTimers::WaitUpTime и вызывать termWaiting(),
-    // чтобы избежать ситуации, когда процесс до заказа таймера 'спал'(в функции waitMessage()) и после
+    // При реализации с использованием waitMessage() каждый раз при вызове askTimer() необходимо 
+    // проверять возвращаемое значение на UniSetTimers::WaitUpTime и вызывать termWaiting(), 
+    // чтобы избежать ситуации, когда процесс до заказа таймера 'спал'(в функции waitMessage()) и после 
     // заказа продолжит спать(т.е. обработчик вызван не будет)...
     try
-    {
+    {    
         if( waitMessage(msg, sleepTime) )
             processingMessage(&msg);
 

src/Processes/NCRestorer_XML.cc

@@ -96,13 +96,13 @@ void NCRestorer_XML::init( const std::string& fname )
     }
 }
 // ------------------------------------------------------------------------------------------
-void NCRestorer_XML::dump(const IONotifyController* ic, SInfo& inf,
+void NCRestorer_XML::dump(const IONotifyController* ic, SInfo& inf, 
                     const IONotifyController::ConsumerListInfo& lst)
 {
     uwarn << "NCRestorer_XML::dump NOT SUPPORT!!!!" << endl;
 }
 // ------------------------------------------------------------------------------------------
-void NCRestorer_XML::dumpThreshold(const IONotifyController* ic, SInfo& inf,
+void NCRestorer_XML::dumpThreshold(const IONotifyController* ic, SInfo& inf, 
                     const IONotifyController::ThresholdExtList& lst)
 {
     uwarn << "NCRestorer_XML::dumpThreshold NOT SUPPORT!!!!" << endl;
@@ -312,7 +312,7 @@ bool NCRestorer_XML::getSensorInfo( const UniXML& xml, xmlNode* it, SInfo& inf )
         inf.d_si.id = conf->getSensorID(d_txt);
         if( inf.d_si.id == UniSetTypes::DefaultObjectId )
         {
-            ucrit << "(NCRestorer_XML:getSensorInfo): sensor='"
+            ucrit << "(NCRestorer_XML:getSensorInfo): sensor='" 
                     << xml.getProp(it,"name") << "' err: "
                     << " Unknown SensorID for depend='"  << d_txt
                     << endl;
@@ -343,7 +343,7 @@ void NCRestorer_XML::read_thresholds(const UniXML& xml, xmlNode* node, IONotifyC
         NCRestorer_XML::SInfo inf;
         if( !getSensorInfo(xml,it.getCurrent(),inf) )
         {
-            uwarn << ic->getName()
+            uwarn << ic->getName() 
                 << "(read_thresholds): не смог получить информацию по датчику" << endl;
             continue;
         }
@@ -360,17 +360,17 @@ void NCRestorer_XML::read_thresholds(const UniXML& xml, xmlNode* node, IONotifyC
             IONotifyController::ThresholdInfoExt ti(0,0,0,0);
             if( !getThresholdInfo(xml,tit,ti) )
             {
-                uwarn << ic->getName()
+                uwarn << ic->getName() 
                             << "(read_thresholds): не смог получить информацию о пороге"
                             << " для датчика "
                             << conf->oind->getNameById(inf.si.id) << endl;
                 continue;
             }
 
-            uinfo  << "(read_thresholds): \tthreshold low="
+            uinfo  << "(read_thresholds): \tthreshold low=" 
                      << ti.lowlimit << " \thi=" << ti.hilimit
-                     << " \t sid=" << ti.sid
-                     << " \t invert=" << ti.invert
+                     << " \t sid=" << ti.sid 
+                     << " \t invert=" << ti.invert 
                      << endl << flush;
 
             xmlNode* cnode = find_node(xml,tit,"consumers","");
@@ -381,9 +381,9 @@ void NCRestorer_XML::read_thresholds(const UniXML& xml, xmlNode* node, IONotifyC
                 {
                     if( !getConsumerList(xml,ask_it,ti.clst) )
                     {
-                        uwarn << ic->getName()
+                        uwarn << ic->getName() 
                                 << "(read_thresholds): не смог получить список заказчиков"
-                                << " для порога " << ti.id
+                                << " для порога " << ti.id 
                                 << " датчика " << conf->oind->getNameById(inf.si.id) << endl;
                     }
                 }
@@ -399,7 +399,7 @@ void NCRestorer_XML::read_thresholds(const UniXML& xml, xmlNode* node, IONotifyC
 }
 // ------------------------------------------------------------------------------------------
 
-void NCRestorer_XML::read_consumers( const UniXML& xml, xmlNode* it,
+void NCRestorer_XML::read_consumers( const UniXML& xml, xmlNode* it, 
                                         NCRestorer_XML::SInfo&& inf, IONotifyController* ic )
 {
     // в новых ask-файлах список выделен <consumers>...</consumers>,
@@ -417,7 +417,7 @@ void NCRestorer_XML::read_consumers( const UniXML& xml, xmlNode* it,
 }
 // ------------------------------------------------------------------------------------------
 
-bool NCRestorer_XML::getConsumerList( const UniXML& xml, xmlNode* node,
+bool NCRestorer_XML::getConsumerList( const UniXML& xml, xmlNode* node, 
                                         IONotifyController::ConsumerListInfo& lst )
 {
     UniXML_iterator it(node);
@@ -439,7 +439,7 @@ bool NCRestorer_XML::getConsumerList( const UniXML& xml, xmlNode* node,
 
 }
 // ------------------------------------------------------------------------------------------
-bool NCRestorer_XML::getThresholdInfo( const UniXML& xml,xmlNode* node,
+bool NCRestorer_XML::getThresholdInfo( const UniXML& xml,xmlNode* node, 
                                         IONotifyController::ThresholdInfoExt& ti )
 {
     UniXML_iterator uit(node);
@@ -450,7 +450,7 @@ bool NCRestorer_XML::getThresholdInfo( const UniXML& xml,xmlNode* node,
         ti.sid = conf->getSensorID(sid_name);
         if( ti.sid == UniSetTypes::DefaultObjectId )
         {
-            ucrit << "(NCRestorer_XML:getThresholdInfo): "
+            ucrit << "(NCRestorer_XML:getThresholdInfo): " 
                     << " Not found ID for " << sid_name << endl;
         }
         else

src/Timers/PassiveSysTimer.cc

@@ -71,7 +71,7 @@ void PassiveSysTimer::init()
     {
         cerr << "PassiveSysTimer: error sigaction" << endl;
         throw NotSetSignal("PassiveTimer: errir sigaction");
-    }
+    }    
 */
 }
 // ------------------------------------------------------------------------------------------
@@ -101,7 +101,7 @@ bool PassiveSysTimer::wait(timeout_t timeMS)
     {
         cerr << "PassiveSysTimer: error sigaction" << endl;
         return false;
-    }
+    }    
 
 
 //    if ( !terminated )
@@ -110,7 +110,7 @@ bool PassiveSysTimer::wait(timeout_t timeMS)
 
     timeout_t sec;
     timeout_t msec;
-
+    
     if (timeMS == WaitUpTime)
     {
         sec=15*60; // 15min
@@ -129,7 +129,7 @@ bool PassiveSysTimer::wait(timeout_t timeMS)
     setitimer( ITIMER_REAL, &mtimer, (struct itimerval *)0 );
 
     PassiveTimer::setTiming(timeMS); // вызываем для совместимости с обычным PassiveTimer-ом
-
+    
     sigset_t mask, oldmask;
 
     sigemptyset(&mask);
@@ -146,7 +146,7 @@ bool PassiveSysTimer::wait(timeout_t timeMS)
 
     terminated = 1;
     sigprocmask( SIG_UNBLOCK, &mask, NULL );
-
+    
 //    cout << "PassiveSysTimer: time ok"<< endl;
     return true;
 }
@@ -158,21 +158,21 @@ bool PassiveSysTimer::wait(timeout_t timeMS)
     struct itimerspec val;
     struct tm do_time;
     timer_t t_id;
-
+    
     sigemptyset(&sigv.sa_mask);
     sigv.sa_flags = SA_SIGINFO;
     sigv.sa_sigaction = call;
-
+    
     if (sigaction (SIGUSR1, &sigv, 0) == -1)
     {
         cerr << "Timer: sigaction" << endl;
         return -1;
     }
-
+    
     sigx.sigev_notify = SIGEV_SIGNAL;
     sigx.sigev_signo = SIGUSR1;
     sigx.sigev_value.sival_int = timeMS;
-
+    
     if ( timer_create(CLOCK_REALTIME, &sigx, &t_id) == -1 )
     {
         cerr << "Timer: timer create" << endl;
@@ -181,7 +181,7 @@ bool PassiveSysTimer::wait(timeout_t timeMS)
 
     int sec=timeMS/1000;
     int micsec=(timeMS%1000)*1000;
-
+    
     val.it_value.tv_sec    = sec;
     val.it_value.tv_nsec= micsec;
     val.it_interval.tv_sec    = sec;
@@ -197,6 +197,6 @@ bool PassiveSysTimer::wait(timeout_t timeMS)
     {
         cerr << "Timer: timer delete" << endl;
     }
-
+    
     return 0;
 */

src/Timers/WaitingPassiveTimer.cc

@@ -37,10 +37,10 @@ void WaitingPassiveTimer::checkCount()
     {
         char err[200];
         sprintf(err,"LimitThrPassiveTimers: превышено максимальное количество таймеров %d", MAX_COUNT_THRPASSIVE_TIMERS);
-        throw LimitWaitingPTimers(err);
+        throw LimitWaitingPTimers(err); 
     }
-
-    countTimers++;
+    
+    countTimers++;    
 }
 
 WaitingPassiveTimer::WaitingPassiveTimer()throw(LimitWaitingPTimers):
@@ -86,26 +86,26 @@ void WaitingPassiveTimer::work()
     terminated = false;
     while( !terminated )
     {
-        usleep(sleepMKS);
+        usleep(sleepMKS); 
         if ( checkTime() )
             break;
     }
-
+    
     terminated = true;
     if(pValue != NULL)
         *pValue ^= true;
-/*
+/*    
     if(pCall!=NULL)
     {
         pCall();
     }
 
-*/
+*/    
 /*
     check = false;
     pause();
     check = true;
-*/
+*/    
     stop();
 //    cout << "Timer: завершил поток..."<< endl;
 }

src/Various/Configuration.cc

@@ -66,7 +66,7 @@ ostream& UniSetTypes::Configuration::help(ostream& os)
     print_help(os,25,"--uniport num","использовать заданный порт (переопеределяет 'defaultport' заданный в конф. файле в разделе <nodes>)\n");
     print_help(os,25,"--localIOR {1,0}","использовать локальные файлы для получения IOR (т.е. не использовать omniNames). Переопределяет параметр в конфигурационном файле.\n");
     print_help(os,25,"--transientIOR {1,0}","использовать генерируемые IOR(не постоянные). Переопределяет параметр в конфигурационном файле. Default=1\n");
-
+    
     return os << "\nПример использования:\t myUniSetProgram "
               << "--ulog-add-levels level1,info,system,warn --ulog-log-in-file myprogrpam.log\n\n";
 }
@@ -80,7 +80,7 @@ namespace UniSetTypes
 Configuration::Configuration():
     oind(NULL),
     NSName("NameService"),
-    repeatCount(2),repeatTimeout(100),
+    repeatCount(2),repeatTimeout(100),     
     localDBServer(UniSetTypes::DefaultObjectId),
     localNode(UniSetTypes::DefaultObjectId),
     localNodeName(""),
@@ -124,7 +124,7 @@ Configuration::Configuration( int argc, const char* const* argv, ObjectIndex* _o
     _argc(argc),
     _argv(argv),
     NSName("NameService"),
-    repeatCount(2),repeatTimeout(100),
+    repeatCount(2),repeatTimeout(100), 
     localDBServer(UniSetTypes::DefaultObjectId),
     localNode(UniSetTypes::DefaultObjectId),
     localNodeName(""),
@@ -143,7 +143,7 @@ Configuration::Configuration( int argc, const char* const* argv, const string& f
     _argc(argc),
     _argv(argv),
     NSName("NameService"),
-    repeatCount(2),repeatTimeout(100),
+    repeatCount(2),repeatTimeout(100), 
     localDBServer(UniSetTypes::DefaultObjectId),
     localNode(UniSetTypes::DefaultObjectId),
     localNodeName(""),
@@ -203,7 +203,7 @@ void Configuration::initConfiguration( int argc, const char* const* argv )
 
 //    cerr << "*************** initConfiguration: xmlOpen: " << pt.getCurrent() << " msec " << endl;
 //    pt.reset();
-
+    
         // Init ObjectIndex interface
         {
             if( oind == NULL )
@@ -229,7 +229,7 @@ void Configuration::initConfiguration( int argc, const char* const* argv )
                 }
             }
         }
-
+    
         // Настраиваем отладочные логи
         initDebug(ulog,"UniSetDebug");
 
@@ -294,7 +294,7 @@ void Configuration::initConfiguration( int argc, const char* const* argv )
              ostringstream uri;
             uri << "corbaname::" << it.host << ":" << it.port;
             if( !omni::omniInitialReferences::setFromArgs(name.c_str(), uri.str().c_str()) )
-                cerr << "**********************!!!! FAILED ADD name=" << name << " uri=" << uri.str() << endl;
+                cerr << "**********************!!!! FAILED ADD name=" << name << " uri=" << uri.str() << endl; 
 
             assert( i < _argc );
         }
@@ -329,12 +329,12 @@ void Configuration::initConfiguration( int argc, const char* const* argv )
                 ostringstream uri;
                 uri << "corbaname::" << getProp(nsnode,"host") << ":" << defPort;
                 if( !omni::omniInitialReferences::setFromArgs(ns_name.str().c_str(), uri.str().c_str()) )
-                    cerr << "**********************!!!! FAILED ADD name=" <<ns_name << " uri=" << uri.str() << endl;
+                    cerr << "**********************!!!! FAILED ADD name=" <<ns_name << " uri=" << uri.str() << endl; 
             }
         }
 
         _argv = new_argv;
-        // ------------- CORBA INIT -------------
+        // ------------- CORBA INIT -------------        
         // orb init
         orb = CORBA::ORB_init(_argc,(char**)_argv);
         // create policy
@@ -357,10 +357,10 @@ void Configuration::initConfiguration( int argc, const char* const* argv )
             pl[1] = root_poa->create_servant_retention_policy(PortableServer::RETAIN);
             pl[2] = root_poa->create_request_processing_policy(PortableServer::USE_ACTIVE_OBJECT_MAP_ONLY);
 //            pl[3] = root_poa->create_thread_policy(PortableServer::SINGLE_THREAD_MODEL);
-        }
-
+        }    
+    
         policyList = pl;
-        // ---------------------------------------
+        // ---------------------------------------        
 
     }
     catch( Exception& ex )
@@ -663,7 +663,7 @@ void Configuration::createNodesList()
         initNode(ninf, it);
         uinfo << "Configuration(createNodesList): add to list of nodes: node=" << nodename << " id=" << ninf.id << endl;
         lnodes.push_back(ninf);
-    }
+    } 
 
     uinfo << "Configuration(createNodesList): size of node list " << lnodes.size() << endl;
 }
@@ -957,7 +957,7 @@ UniversalIO::IOType Configuration::getIOType( UniSetTypes::ObjectId id )
 UniversalIO::IOType Configuration::getIOType( const std::string& name )
 {
     // Если указано "короткое" имя
-    // то просто сперва ищём ID, а потом по нему
+    // то просто сперва ищём ID, а потом по нему 
     // iotype
     ObjectId id = getSensorID(name);
     if( id != DefaultObjectId )

src/Various/Debug.cc

@@ -38,21 +38,21 @@ static error_item errorTags[] = {
     { Debug::LEVEL2,    "level2",    ("UniSet debug level2")},
     { Debug::LEVEL3,    "level3",    ("UniSet debug level3")},
     { Debug::LEVEL4,    "level4",    ("UniSet debug level4")},
-    { Debug::LEVEL5,    "level5",    ("UniSet debug level5")},
+    { Debug::LEVEL5,    "level5",    ("UniSet debug level5")},    
     { Debug::LEVEL6,    "level6",    ("UniSet debug level6")},
     { Debug::LEVEL7,    "level7",    ("UniSet debug level7")},
     { Debug::LEVEL8,    "level8",    ("UniSet debug level8")},
-    { Debug::LEVEL9,    "level9",    ("UniSet debug level9")},
+    { Debug::LEVEL9,    "level9",    ("UniSet debug level9")},    
     { Debug::REPOSITORY,"repository",("UniSet repository messages")},
     { Debug::ANY,       "any",       ("All debugging messages")},
     { Debug::EXCEPTION, "exception", ("Exception debug messages")},
-
+    
 };
 
 
 static const int numErrorTags = sizeof(errorTags)/sizeof(error_item);
 
-
+    
 Debug::type const Debug::ANY = Debug::type(
     Debug::INFO | Debug::INIT | Debug::WARN | Debug::CRIT |
     Debug::LEVEL1 | Debug::LEVEL2 | Debug::LEVEL3 | Debug::LEVEL4 |
@@ -71,13 +71,13 @@ Debug::type Debug::value(string const & val)
         string tmp(v.substr(0, st));
         if (tmp.empty())
             break;
-
+        
         // Is it a number?
-        //if (isStrInt(tmp))
+        //if (isStrInt(tmp)) 
         //    l |= static_cast<type>(strToInt(tmp));
         //else
         // Search for an explicit name
-        for (int i = 0 ; i < numErrorTags ; ++i)
+        for (int i = 0 ; i < numErrorTags ; ++i) 
             if (tmp == errorTags[i].name) {
                 l |= errorTags[i].level;
                 break;
@@ -112,7 +112,7 @@ void Debug::showTags(ostream & os)
 
 std::ostream& operator<<(std::ostream& os, Debug::type level )
 {
-
+    
     for (int i = 0 ; i < numErrorTags ; ++i)
     {
         if( errorTags[i].level & level)        // errorTags[i].level != Debug::ANY && errorTags[i].level != Debug::NONE

src/Various/DebugStream.cc

@@ -216,7 +216,7 @@ const DebugStream& DebugStream::operator=( const DebugStream& r )
     fname = r.fname;
     if( !r.fname.empty() )
         logFile(fname);
-
+    
     return *this;
 }
 //--------------------------------------------------------------------------
@@ -243,7 +243,7 @@ std::ostream & DebugStream::debug(Debug::type t)
         *this << "(" << std::setfill(' ') << std::setw(6) << t << "):  "; // "):\t";
         return *this;
     }
-
+    
     return nullstream;
 }
 //--------------------------------------------------------------------------
@@ -251,7 +251,7 @@ std::ostream& DebugStream::operator()(Debug::type t)
 {
     if(dt & t)
         return *this;
-
+        
     return nullstream;
 }
 //--------------------------------------------------------------------------
@@ -265,7 +265,7 @@ std::ostream& DebugStream::printDate(Debug::type t, char brk)
                       << std::setw(2) << std::setfill('0') << tms->tm_mon+1 << brk
                      << std::setw(4) << std::setfill('0') << tms->tm_year+1900;
     }
-
+    
     return nullstream;
 }
 //--------------------------------------------------------------------------
@@ -279,7 +279,7 @@ std::ostream& DebugStream::printTime(Debug::type t, char brk)
                      << std::setw(2) << std::setfill('0') << tms->tm_min << brk
                      << std::setw(2) << std::setfill('0') << tms->tm_sec;
     }
-
+    
     return nullstream;
 }
 //--------------------------------------------------------------------------
@@ -296,7 +296,7 @@ std::ostream& DebugStream::printDateTime(Debug::type t)
                      << std::setw(2) << std::setfill('0') << tms->tm_min << ":"
                      << std::setw(2) << std::setfill('0') << tms->tm_sec;
     }
-
+    
     return nullstream;
 }
 //--------------------------------------------------------------------------

src/Various/LT_Object.cc

@@ -159,7 +159,7 @@ timeout_t LT_Object::askTimer( UniSetTypes::TimerId timerid, timeout_t timeMS, c
     }
     else // отказ (при timeMS == 0)
     {
-        uinfo << "(LT_askTimer): поступил отказ по таймеру id="<< timerid << endl;
+        uinfo << "(LT_askTimer): поступил отказ по таймеру id="<< timerid << endl;    
         {    // lock
             uniset_rwmutex_wrlock lock(lstMutex);
             tlst.erase( std::remove_if(tlst.begin(),tlst.end(),Timer_eq(timerid)), tlst.end() );

src/Various/Makefile.am

@@ -6,7 +6,7 @@ noinst_LTLIBRARIES = libVarious.la
 libVarious_la_CPPFLAGS 	= $(SIGC_CFLAGS) $(COMCPP_CFLAGS)
 libVarious_la_LIBADD 	= $(SIGC_LIBS) $(COMCPP_LIBS)
 libVarious_la_SOURCES 	= DebugStream.cc Debug.cc UniXML.cc MessageType.cc Configuration.cc \
-	Restorer_XML.cc RunLock.cc Mutex.cc SViewer.cc SMonitor.cc LT_Object.cc WDTInterface.cc
+	Restorer_XML.cc RunLock.cc Mutex.cc SViewer.cc SMonitor.cc LT_Object.cc WDTInterface.cc 	
 
 local-clean:
 	rm -rf *iSK.cc

src/Various/MessageType.cc

@@ -90,7 +90,7 @@ tid(UniSetTypes::DefaultThresholdId)
 }
 
 SensorMessage::SensorMessage(ObjectId id, long value, const IOController_i::CalibrateInfo& ci,
-                            Priority priority,
+                            Priority priority, 
                             UniversalIO::IOType st, ObjectId consumer):
 id(id),
 value(value),
@@ -102,7 +102,7 @@ tid(UniSetTypes::DefaultThresholdId)
 {
     type            = Message::SensorInfo;
     this->priority     = priority;
-    this->consumer     = consumer;
+    this->consumer     = consumer;    
     sm_tv_sec         = tm.tv_sec;
     sm_tv_usec         = tm.tv_usec;
 }
@@ -154,7 +154,7 @@ TimerMessage::TimerMessage(const VoidMessage *msg):
     memcpy(this,msg,sizeof(*this));
     assert(this->type == Message::Timer);
 }
-//--------------------------------------------------------------------------------------------
+//--------------------------------------------------------------------------------------------    
 ConfirmMessage::ConfirmMessage( const VoidMessage *msg ):
     Message(1) // вызываем dummy-конструктор, который не инициализирует данные (оптимизация)
 {
@@ -180,7 +180,7 @@ ConfirmMessage::ConfirmMessage(long in_sensor_id,
    priority = in_priority;
 }
 
-//--------------------------------------------------------------------------------------------
+//--------------------------------------------------------------------------------------------    
 } // end of namespace UniSetTypes
-//--------------------------------------------------------------------------------------------
+//--------------------------------------------------------------------------------------------    
 

src/Various/Mutex.cc

@@ -87,7 +87,7 @@ uniset_mutex_lock::uniset_mutex_lock( uniset_mutex& m, const time_t timeMS ):
     {
         if( !mutex->name().empty() )
         {
-            ulog9 << "(mutex_lock): вышло заданное время ожидания "
+            ulog9 << "(mutex_lock): вышло заданное время ожидания " 
                 << timeMS << " msec для " << mutex->name() << endl;
         }
         return;

src/Various/Restorer_XML.cc

@@ -79,7 +79,7 @@ bool Restorer_XML::getConsumerInfo( UniXML_iterator& it,
         cname = conf->getServicesSection()+"/"+cname;
     else
     {
-        uwarn << "(Restorer_XML:getConsumerInfo): неизвестный тип объекта "
+        uwarn << "(Restorer_XML:getConsumerInfo): неизвестный тип объекта " 
                             << otype << endl;
         return false;
     }
@@ -87,7 +87,7 @@ bool Restorer_XML::getConsumerInfo( UniXML_iterator& it,
     cid = conf->oind->getIdByName(cname);
     if( cid == UniSetTypes::DefaultObjectId )
     {
-        ucrit << "(Restorer_XML:getConsumerInfo): НЕ НАЙДЕН ИДЕНТИФИКАТОР заказчика -->"
+        ucrit << "(Restorer_XML:getConsumerInfo): НЕ НАЙДЕН ИДЕНТИФИКАТОР заказчика -->" 
                             << cname << endl;
         return false;
     }
@@ -100,7 +100,7 @@ bool Restorer_XML::getConsumerInfo( UniXML_iterator& it,
 
     if( cnode == UniSetTypes::DefaultObjectId )
     {
-        ucrit << "(Restorer_XML:getConsumerInfo): НЕ НАЙДЕН ИДЕНТИФИКАТОР узла -->"
+        ucrit << "(Restorer_XML:getConsumerInfo): НЕ НАЙДЕН ИДЕНТИФИКАТОР узла -->" 
                             << cnodename << endl;
         return false;
     }
@@ -119,7 +119,7 @@ bool Restorer_XML::check_consumer_item( UniXML_iterator& it )
     return UniSetTypes::check_filter(it,c_filterField,c_filterValue);
 }
 // -----------------------------------------------------------------------------
-xmlNode* Restorer_XML::find_node( const UniXML& xml, xmlNode* root,
+xmlNode* Restorer_XML::find_node( const UniXML& xml, xmlNode* root, 
                                     const string& nodename, const string& nm )
 {
     UniXML_iterator it(root);
@@ -131,7 +131,7 @@ xmlNode* Restorer_XML::find_node( const UniXML& xml, xmlNode* root,
             {
                 if( nm.empty() )
                     return it;
-
+ 
                 if( xml.getProp(it, "name") == nm )
                     return it;
             }

src/Various/RunLock.cc

@@ -42,18 +42,18 @@ RunLock::~RunLock()
 bool RunLock::isLocked(const string& name)
 {
     FILE *out = fopen( string(name + ".lock" ).c_str(), "r" );
-    if( out )
+    if( out ) 
     {
         char ptr[10];
         fscanf( out, "%9s", ptr );
-
+        
         DIR *d = opendir( "/proc" );
         dirent *dir;
         while((dir = readdir(d)))
         {
             if( !strcmp( ptr, dir->d_name ) )
             {
-                // по хорошему здесь надо бы проверять
+                // по хорошему здесь надо бы проверять 
                 // статус на зомби
 /*
                 string path(dir->d_name);
@@ -70,19 +70,19 @@ bool RunLock::isLocked(const string& name)
                         break;
                     }
                 }
-*/
+*/                
                 uinfo << "(RunLock): programm " << name << " already run" << endl;
 
                 fclose(out);
                 closedir(d);
                 return true;
             }
-        }
+        }    
 
         fclose(out);
         closedir(d);
     }
-
+    
     return false;
 }
 // --------------------------------------------------------------------------
@@ -90,7 +90,7 @@ bool RunLock::lock( const string& name )
 {
     if( !isLocked(name) )
     {
-        FILE *out = fopen( string(name + ".lock" ).c_str(), "w+" );
+        FILE *out = fopen( string(name + ".lock" ).c_str(), "w+" );    
         if(out)
         {
             fprintf( out, "%d\n", getpid() );
@@ -98,14 +98,14 @@ bool RunLock::lock( const string& name )
             return true;
         }
     }
-
+    
     return false;
 }
 // --------------------------------------------------------------------------
 bool RunLock::unlock(const string& name)
 {
     string fname(name + ".lock");
-    FILE *out = fopen( fname.c_str(), "r" );
+    FILE *out = fopen( fname.c_str(), "r" );    
     if( out )
     {
         fclose(out);

src/Various/SMonitor.cc

@@ -21,8 +21,8 @@ SMonitor::SMonitor(ObjectId id):
     script("")
 {
     string sid(conf->getArgParam("--sid"));
-
-    lst = UniSetTypes::getSInfoList(sid,UniSetTypes::conf);
+    
+    lst = UniSetTypes::getSInfoList(sid,UniSetTypes::conf); 
 
     if( lst.empty() )
         throw SystemError("Не задан список датчиков (--sid)");
@@ -84,7 +84,7 @@ void SMonitor::sysCommand( const SystemMessage *sm )
 // ------------------------------------------------------------------------------------------
 void SMonitor::sensorInfo( const SensorMessage* si )
 {
-    cout << "(" << setw(6) << si->id << "): " << setw(8) << timeToString(si->sm_tv_sec,":")
+    cout << "(" << setw(6) << si->id << "): " << setw(8) << timeToString(si->sm_tv_sec,":") 
          << "(" << setw(6) << si->sm_tv_usec << "): ";
     cout << setw(45) << conf->oind->getMapName(si->id);
     cout << "\tvalue=" << si->value << "\tfvalue=" << ( (float)si->value / pow(10.0,si->ci.precision) ) << endl;
@@ -97,7 +97,7 @@ void SMonitor::sensorInfo( const SensorMessage* si )
         if( script[0] == '.' || script[0] == '/' )
             cmd << script;
         else
-            cmd << conf->getBinDir() << script;
+            cmd << conf->getBinDir() << script;    
 
         cmd << " " << si->id << " " << si->value << " " << si->sm_tv_sec << " " << si->sm_tv_usec;
 

src/Various/SViewer.cc

@@ -50,7 +50,7 @@ SViewer::~SViewer()
 
 void SViewer::on_SViewer_destroy()
 {
-//    activator->oakill(SIGINT);
+//    activator->oakill(SIGINT); 
 //    msleep(500);
 //    activator->oakill(SIGKILL);
 }
@@ -82,14 +82,14 @@ void SViewer::view()
 void SViewer::readSection( const string& section, const string& secRoot )
 {
     ListObjectName lst;
-    string curSection;
+    string curSection;    
     try
     {
         if ( secRoot.empty() )
             curSection = section;
         else
             curSection=secRoot+"/"+section;
-
+        
 //        cout << " read sectionlist ..."<< endl;
         if( !rep.listSections(curSection, &lst, 1000) )
         {
@@ -102,7 +102,7 @@ void SViewer::readSection( const string& section, const string& secRoot )
         cout << "(readSection): get sectionlist ... catch..." << endl;
     }
 
-    if( !lst.empty() )
+    if( !lst.empty() )    
     {
         for ( ListObjectName::const_iterator li=lst.begin();li!=lst.end();++li)
         {
@@ -184,7 +184,7 @@ void SViewer::getInfo( ObjectId id )
 
         IOController_i::SensorInfoSeq_var amap = ioc->getSensorsMap();
         IONotifyController_i::ThresholdsListSeq_var tlst = ioc->getThresholdsList();
-
+    
         try
         { updateSensors(amap, id);
         }catch(...){}
@@ -226,7 +226,7 @@ void SViewer::updateSensors( IOController_i::SensorInfoSeq_var& amap, UniSetType
             printInfo( amap[i].si.id, name, amap[i].value, owner, txtname, "AI");
         }
     }
-    cout << "------------------------------------------------------\n";
+    cout << "------------------------------------------------------\n";    
 
     cout << "\n======================================================\n" << owner;
     cout << "\t Выходы";
@@ -242,7 +242,7 @@ void SViewer::updateSensors( IOController_i::SensorInfoSeq_var& amap, UniSetType
             printInfo( amap[i].si.id, name, amap[i].value, owner, txtname, "AO");
         }
     }
-    cout << "------------------------------------------------------\n";
+    cout << "------------------------------------------------------\n";    
 
 }
 // ---------------------------------------------------------------------------
@@ -276,7 +276,7 @@ void SViewer::updateThresholds( IONotifyController_i::ThresholdsListSeq_var& tls
         if( isShort )
                 sname = ORepHelpers::getShortName(sname);
 
-        cout << " | " << setw(60) << sname << " | " << setw(5) << tlst[i].value << endl;
+        cout << " | " << setw(60) << sname << " | " << setw(5) << tlst[i].value << endl; 
 
         int m = tlst[i].tlist.length();
         for( unsigned int k=0; k<m; k++ )

src/Various/UniXML.cc

@@ -106,7 +106,7 @@ void UniXML::close()
         xmlFreeDoc(doc);
         doc=0;
     }
-
+    
     filename = "";
 }
 
@@ -121,7 +121,7 @@ string UniXML::getProp(const xmlNode* node, const string& name)
     const char * text = (const char*)::xmlGetProp((xmlNode*)node, (const xmlChar*)name.c_str());
     if( text == NULL )
         return "";
-
+    
     string t(text);
     xmlFree( (void*)text );
     return t;
@@ -137,7 +137,7 @@ int UniXML::getPIntProp(const xmlNode* node, const string& name, int def )
     string param = getProp(node,name);
     if( param.empty() )
         return def;
-
+    
     return UniSetTypes::uni_atoi(param);
 }
 
@@ -173,7 +173,7 @@ xmlNode* UniXML::copyNode(xmlNode* node, int recursive)
 /*!    \bug Почему-то портятся русские имена (точнее становятся UTF8)
         независимо от текущей локали файла
          спасает только такое вот дополнительное копирование списка свойств
-    \bug Непонятный параметр 'target'
+    \bug Непонятный параметр 'target' 
         - при указании NULL нормально работает
         - при указании copynode - проблеммы с русским при сохранении
         - при указании node - SEGFAULT при попытке удалить исходный(node) узел
@@ -323,7 +323,7 @@ bool UniXML_iterator::goThrowNext()
         return goThrowNext();
     return true;
 }
-// -------------------------------------------------------------------------
+// -------------------------------------------------------------------------        
 bool UniXML_iterator::goPrev()
 {
     if( !curNode ) // || !curNode->prev )
@@ -335,33 +335,33 @@ bool UniXML_iterator::goPrev()
         return goPrev();
     return true;
 }
-// -------------------------------------------------------------------------
+// -------------------------------------------------------------------------        
 bool UniXML_iterator::canPrev()
 {
     if( !curNode || !curNode->prev )
         return false;
     return true;
 }
-// -------------------------------------------------------------------------
+// -------------------------------------------------------------------------        
 bool UniXML_iterator::canNext()
 {
     if (!curNode || !curNode->next )
         return false;
     return true;
 }
-// -------------------------------------------------------------------------
+// -------------------------------------------------------------------------        
 bool UniXML_iterator::goParent()
 {
     if( !curNode )
         return false;
-
+    
     if( !curNode->parent )
         return false;
-
+        
     curNode = curNode->parent;
     return true;
 }
-// -------------------------------------------------------------------------
+// -------------------------------------------------------------------------        
 bool UniXML_iterator::goChildren()
 {
     if (!curNode || !curNode->children )
@@ -422,9 +422,9 @@ void UniXML_iterator::setProp( const string& name, const string& text )
     UniXML::setProp(curNode, name, text);
 }
 
-// -------------------------------------------------------------------------
+// -------------------------------------------------------------------------    
 bool UniXML_iterator::findName( const std::string& node, const std::string& searchname )
-{
+{    
     while( this->find(node) )
     {
         if ( searchname == getProp("name") )
@@ -435,47 +435,47 @@ bool UniXML_iterator::findName( const std::string& node, const std::string& sear
     return false;
 }
 
-// -------------------------------------------------------------------------
+// -------------------------------------------------------------------------    
 bool UniXML_iterator::find( const std::string& searchnode )
-{
+{    
     // Функция ищет "в ширину и в глубь"
 
     xmlNode* rnode = curNode;
-
+    
     while (curNode != NULL)
-    {
+    {    
         while( curNode->children )
         {
             curNode = curNode->children;
-
+            
             if ( searchnode == (const char*)curNode->name )
                 return true;
         }
 
         while( !curNode->next && curNode->parent )
-        {
+        {    
             // выше исходного узла "подыматься" нельзя
             if( curNode == rnode )
-                break;
+                break;            
 
             curNode = curNode->parent;
         }
-
+        
         curNode = curNode->next;
-
+    
         if ( curNode && searchnode == (const char*)curNode->name )
-        {
+        {    
             return true;
         }
     }
-
+    
     return false;
 }
-// -------------------------------------------------------------------------
+// -------------------------------------------------------------------------    
 UniXML_iterator UniXML_iterator::operator++()
 {
     if (!curNode->next)
-    {
+    {    
         curNode=curNode->next;
         return *this;
     }
@@ -486,7 +486,7 @@ UniXML_iterator UniXML_iterator::operator++()
         if (getName() == "text" || getName() == "comment")
             continue;
         else
-            break;
+            break;    
     }
 
     return *this;
@@ -497,18 +497,18 @@ UniXML_iterator UniXML_iterator::operator++(int)
     UniXML_iterator it = *this;
 
     if (!curNode->next)
-    {
+    {    
         curNode=curNode->next;
         return it;
     }
-
+    
     for(;;)
     {
         curNode=curNode->next;
         if (getName() == "text" || getName() == "comment")
             continue;
         else
-            break;
+            break;    
     }
 
     return it;
@@ -518,7 +518,7 @@ UniXML_iterator UniXML_iterator::operator++(int)
 UniXML_iterator UniXML_iterator::operator--()
 {
     if (!curNode->prev)
-    {
+    {    
         curNode=curNode->prev;
         return *this;
     }
@@ -529,7 +529,7 @@ UniXML_iterator UniXML_iterator::operator--()
         if (getName() == "text" || getName() == "comment")
             continue;
         else
-            break;
+            break;    
     }
 
     return *this;
@@ -540,18 +540,18 @@ UniXML_iterator UniXML_iterator::operator--(int)
     UniXML_iterator it = *this;
 
     if (!curNode->prev)
-    {
+    {    
         curNode=curNode->prev;
         return it;
     }
-
+    
     for(;;)
     {
         curNode=curNode->prev;
         if (getName() == "text" || getName() == "comment")
             continue;
         else
-            break;
+            break;    
     }
 
     return it;

src/Various/WDTInterface.cc

-// --------------------------------------------------------------------------
+// --------------------------------------------------------------------------    
 // --------------------------------------------------------------------------
 #include <iostream>
 #include <cstring>
@@ -43,7 +43,7 @@ bool WDTInterface::stop()
         cerr << ": Unable to open device " << dev << " with err: " << strerror(errno) << endl;
         return false;
     }
-
+    
     write(fd, (void*)CMD_STOP, sizeof(CMD_STOP));
     close(fd);
     return true;

tests/UniXmlTest/XmlTest.cc

@@ -28,7 +28,7 @@
 
 int main()
 {
-
+    
     UniXML* f = new UniXML();
     f->newDoc("journal");
     xmlNode *cur,*beg;

tests/calibration.cc

@@ -21,12 +21,12 @@ int main(int argc, const char **argv)
 //        conf = new Configuration(argc, argv, confile);
         for( int i=-5; i<4095; i+=100 )
         {
-
+            
             cout <<  "raw=" << (817+i)
-                 <<  "   cal=" << lcalibrate(817+i,817,4095,0,400)
+                 <<  "   cal=" << lcalibrate(817+i,817,4095,0,400) 
                  << endl;
         }
-
+        
         return 0;
     }
     catch(SystemError& err)
@@ -41,6 +41,6 @@ int main(int argc, const char **argv)
     {
         cerr << "(calibration): catch(...)" << endl;
     }
-
+    
     return 1;
 }

tests/conftest.cc

@@ -14,7 +14,7 @@ int main(int argc, const char **argv)
         cout << "--confile    - Configuration file. Default: test.xml" << endl;
         return 0;
     }
-
+    
     cout << "**** uni_atoi('')=" << uni_atoi("") << endl;
 
     try
@@ -23,7 +23,7 @@ int main(int argc, const char **argv)
         conf = new Configuration(argc, argv, confile);
 
         cout << "getLocalNode()=" << conf->getLocalNode() << endl;
-
+        
         string t(conf->oind->getTextName(1));
         cout << "**** check getTextName: " << ( t.empty() ?  "FAILED" : "OK" ) << endl;
 
@@ -35,8 +35,8 @@ int main(int argc, const char **argv)
         cout << "**** check getMapName: " << ( mn.empty() ?  "FAILED" : "OK" ) << endl;
 
 
-        cout << "getSensorID(Input1_S): " << conf->getSensorID("Input1_S") << endl;
-
+        cout << "getSensorID(Input1_S): " << conf->getSensorID("Input1_S") << endl; 
+        
         std::string iname = conf->oind->getNameById(1);
         cout << "getNameById(1): " << iname << endl;
 
@@ -45,11 +45,11 @@ int main(int argc, const char **argv)
 
         UniversalIO::IOType t1=conf->getIOType(1);
         cout << "**** getIOType for " << mn << endl;
-        cout << "**** check getIOType(id): (" << t1 << ") " << ( t1 == UniversalIO::UnknownIOType ?  "FAILED" : "OK" ) << endl;
+        cout << "**** check getIOType(id): (" << t1 << ") " << ( t1 == UniversalIO::UnknownIOType ?  "FAILED" : "OK" ) << endl;        
         UniversalIO::IOType t2=conf->getIOType(mn);
-        cout << "**** check getIOType(name): (" << t2 << ") " << ( t2 == UniversalIO::UnknownIOType ?  "FAILED" : "OK" ) << endl;
+        cout << "**** check getIOType(name): (" << t2 << ") " << ( t2 == UniversalIO::UnknownIOType ?  "FAILED" : "OK" ) << endl;        
         UniversalIO::IOType t3=conf->getIOType("Input1_S");
-        cout << "**** check getIOType(name): for short name 'Input1_S': (" << t3 << ") " << ( t3 == UniversalIO::UnknownIOType ?  "FAILED" : "OK" ) << endl;
+        cout << "**** check getIOType(name): for short name 'Input1_S': (" << t3 << ") " << ( t3 == UniversalIO::UnknownIOType ?  "FAILED" : "OK" ) << endl;        
 
 
         int i1 = uni_atoi("-100");
@@ -57,7 +57,7 @@ int main(int argc, const char **argv)
 
         int i2 = uni_atoi("20");
         cout << "**** check uni_atoi: '20' " << ( ( i2 != 20 ) ? "FAILED" : "OK" ) << endl;
-
+        
         xmlNode* cnode = conf->getNode("testnode");
         if( cnode == NULL )                                                                                                                                                         
         {                                                                                                                                                                           
@@ -83,10 +83,10 @@ int main(int argc, const char **argv)
 
         int prop5 = conf->getArgPInt("--prop-dummy",it.getProp("dummy"),0);
         cerr << "**** check conf->getArgPInt(...,...,defval): " << ( (prop5 != 0) ? "[FAILED]" : "OK" ) << endl;
+        
 
 
-
-
+        
         return 0;
     }
     catch(SystemError& err)
@@ -101,6 +101,6 @@ int main(int argc, const char **argv)
     {
         cerr << "(conftest): catch(...)" << endl;
     }
-
+    
     return 1;
 }

tests/delaytimer.cc

@@ -8,7 +8,7 @@ using namespace std;
 
 int main()
 {
-    // ----------------------
+    // ---------------------- 
     // test DelayTimer
     DelayTimer dtm(1000,500);
 
@@ -85,14 +85,14 @@ int main()
     if( !dtm2.check(true) )
     {
         cerr << "DelayTimer: TEST9 FAILED! " << endl;
-        return 1;
+        return 1;    
     }
     cerr << "DelayTimer: TEST9 OK! " << endl;
 
     if( dtm2.check(false) )
     {
         cerr << "DelayTimer: TEST10 FAILED! " << endl;
-        return 1;
+        return 1;    
     }
     cerr << "DelayTimer: TEST10 OK! " << endl;
 
@@ -106,7 +106,7 @@ int main()
     if( dtm3.check(true) )
     {
         cerr << "DelayTimer: TEST11 FAILED! " << endl;
-        return 1;
+        return 1;    
     }
     cerr << "DelayTimer: TEST11 OK! " << endl;
 
@@ -114,7 +114,7 @@ int main()
     if( !dtm3.check(true) )
     {
         cerr << "DelayTimer: TEST12 FAILED! " << endl;
-        return 1;
+        return 1;    
     }
     cerr << "DelayTimer: TEST12 OK! " << endl;
 

tests/dlog.cc

@@ -8,9 +8,9 @@ using namespace UniSetTypes;
 int main( int argc, const char **argv )
 {
     DebugStream tlog;
-
+    
     tlog.addLevel(Debug::ANY);
-
+    
     tlog[Debug::INFO] << ": [info] ..." << endl;
     tlog(Debug::INFO) << ": (info) ..." << endl;
     cout << endl;

tests/hourglass.cc

@@ -9,7 +9,7 @@ using namespace std;
 int main()
 {
     HourGlass hg;
-
+    
     hg.run(1000);
     hg.rotate(true);
     msleep(200);
@@ -18,14 +18,14 @@ int main()
         cerr << "HourGlass: TEST1 FAILED! " << endl;
         return 1;
     }
-
+    
     msleep(1000);
     if( !hg.check() )
     {
         cerr << "HourGlass: TEST1 FAILED! " << endl;
         return 1;
     }
-
+    
     cout << "HourGlass: TEST1 OK!" << endl;
 
     hg.rotate(false);

tests/iterator_test.cc

@@ -24,12 +24,12 @@ void myf(xmlNode it)
 {
     cout<<it.name<<endl;
 }
-
+    
 int main()
 {
         UniXML xml("iterator_test.xml");
         UniXML::iterator it=xml.begin();
-
+        
         it.find("messages");
         check( "Check find():", "messages", it.getName() );
 
@@ -58,7 +58,7 @@ int main()
         --it;
         check( "Check iterator -- :", "a2", it.getName() );
 
-
+        
         it=xml.begin();
         it.goChildren();
         cout<<"Check algorythm 'for_each()':\n";
@@ -73,6 +73,6 @@ int main()
         if( it.find("messages") )
             cout << "ERROR! begin=<UniSet> but find <messages>!" << endl;
 
-
+        
     return 0;
 }

tests/passivetimer.cc

@@ -18,7 +18,7 @@ int main()
 
     PassiveTimer pt1(5000);
     cout << " pt1.getInterval()=" << pt1.getInterval() << " TEST: " << ((pt1.getInterval()==5000) ? "OK" : "FAILED") << endl;
-
+    
     PassiveTimer pt2;
     cout << " pt2.getInterval()=" << pt2.getInterval() << endl;
     if( pt2.getInterval() != 0 )

tests/threadtst.cc

@@ -22,22 +22,22 @@ class MyClass
         {
             thr = new ThreadCreator<MyClass>(this, &MyClass::thread);
         }
-
+        
         ~MyClass()
         {
             delete thr;
         }
-
+                
         inline cctid_t start(){ return thr->start(); }
         inline void stop(){ thr->stop(); }
-        inline pid_t getTID(){ return thr->getTID(); }
+        inline pid_t getTID(){ return thr->getTID(); }        
 
         // BAD code...only for tests
-        inline ThreadCreator<MyClass>* mythr(){ return thr; }
-
+        inline ThreadCreator<MyClass>* mythr(){ return thr; }        
+            
     protected:
         std::string nm;
-
+        
 
         void thread()
         {
@@ -49,7 +49,7 @@ class MyClass
 
             cout << nm << ": finish thread (" << getTID() << ")" << endl;
         }
-
+                
         private:
             ThreadCreator<MyClass>* thr;
 };
@@ -61,17 +61,17 @@ class MyClass2
         {
             thr = new ThreadCreator<MyClass2>(this, &MyClass2::thread);
         }
-
+        
         ~MyClass2(){ delete thr; }
-
+                
         inline cctid_t start(){ return thr->start(); }
         inline void stop(){ thr->stop(); }
-        inline pid_t getTID(){ return thr->getTID(); }
-
+        inline pid_t getTID(){ return thr->getTID(); }        
+            
     protected:
         std::string nm;
         TCPCheck tcp;
-
+        
         void thread()
         {
             pthread_setcancelstate(PTHREAD_CANCEL_ENABLE,NULL);
@@ -91,7 +91,7 @@ class MyClass2
 
             cout << nm << ": finish thread (" << getTID() << ")" << endl;
         }
-
+                
         private:
             ThreadCreator<MyClass2>* thr;
 };
@@ -115,7 +115,7 @@ int main( int argc, const char **argv )
 
         cout << "start2..." << endl;
         t1.start();
-
+    
         int prior = t1.mythr()->getPriority();
         cout << "priority: " << prior << endl;
 
@@ -136,7 +136,7 @@ int main( int argc, const char **argv )
 
 //        cout << "start3..." << endl;
 //        t1.start();
-
+    
 //        pause();
 
         cout << "finished3..." << endl;
@@ -149,8 +149,8 @@ int main( int argc, const char **argv )
 
         msleep(50);
         cout << "check finished..." << endl;
-
-
+    
+    
         // поток в потоке..
         MyClass2 t2("Thread2");
         cout << "thread2 start..." << endl;

tests/ui.cc

@@ -44,7 +44,7 @@ int main( int argc, const char **argv )
 
         char t_str[ 150 ];
         strftime( t_str, sizeof(t_str), "%d %b %Y %H:%M:%S", tms );
-
+    
         cout << "id=" << id
             << " value=" << inf.value
             << " last changed: " << string(t_str) << endl;
@@ -62,7 +62,7 @@ int main( int argc, const char **argv )
     {
         cout << "(uitest): catch ..."<< endl;
     }
-
+    
 
     return 0;
 }

tests/umutex.cc

@@ -18,26 +18,26 @@ class MyClass
         {
             thr = new ThreadCreator<MyClass>(this, &MyClass::thread);
         }
-
+        
         ~MyClass()
         {
             delete thr;
         }
-
+                
         void execute()
         {
             thr->start();
         }
-
+        
         void terminate() { term=true; }
 
         inline std::string name(){ return nm; }
         inline int lock_count(){ return count; }
-
-
+        
+        
         // BAD CODE... only for test..
         inline ThreadCreator<MyClass>* get(){ return thr; }
-
+            
     protected:
         std::string nm;
         std::atomic_bool term;
@@ -52,7 +52,7 @@ class MyClass
                 }
             }
         }
-
+                
         private:
             ThreadCreator<MyClass>* thr;
             int count;
@@ -65,12 +65,12 @@ class MyClassSpin
         {
             thr = new ThreadCreator<MyClassSpin>(this, &MyClassSpin::thread);
         }
-
+        
         ~MyClassSpin()
         {
             delete thr;
         }
-
+                
         void execute()
         {
             thr->start();
@@ -81,10 +81,10 @@ class MyClassSpin
 
         inline std::string name(){ return nm; }
         inline int lock_count(){ return count; }
-
+  
         // BAD CODE... only for test..
         inline ThreadCreator<MyClassSpin>* get(){ return thr; }
-
+            
     protected:
         std::string nm;
         bool readLock;
@@ -104,17 +104,17 @@ class MyClassSpin
                     uniset_rwmutex_rlock l(m_rw);
                     count++;
                 }
-
+                
                 //msleep(20);
             }
         }
-
+                
         private:
             ThreadCreator<MyClassSpin>* thr;
             int count;
     };
-
-
+        
+        
 bool check_wr_lock( ost::ThreadLock& m )
 {
     if( m.tryWriteLock() )
@@ -122,7 +122,7 @@ bool check_wr_lock( ost::ThreadLock& m )
         m.unlock();
         return true;
     }
-
+    
     return false;
 }
 
@@ -133,7 +133,7 @@ bool check_r_lock( ost::ThreadLock& m )
         m.unlock();
         return true;
     }
-
+    
     return false;
 }
 
@@ -142,60 +142,60 @@ int main( int argc, const char **argv )
     try
     {
 #if 0
-	{
-		cout << "check timed_mutex..." << endl;
-		std::timed_mutex m;
-
-		cout << " 'unlock' without 'lock'..";
-		m.unlock();
-		cout << " ok." << endl;
+    	{
+    		cout << "check timed_mutex..." << endl;
+    	 	std::timed_mutex m;
+    	 	
+    	 	cout << " 'unlock' without 'lock'..";
+    	 	m.unlock();
+    	 	cout << " ok." << endl;
 
 			cout << "try lock (lock): " << ( m.try_lock() ? "OK" : "FAIL" ) << endl;
 
 			m.unlock();
-
-		m.lock();
+			
+    	 	m.lock();
 
 			cout << "try lock (fail): " << ( m.try_lock() ? "FAIL" : "OK" ) << endl;
-		m.unlock();
-	}
-
-
-	{
-		uniset_mutex m("testmutex");
-		{
-			uniset_mutex_lock l(m);
-			msleep(20);
-		}
-
-		{
-			uniset_mutex_lock l(m,100);
-			msleep(50);
-		}
-
-	}
+    	 	m.unlock();
+    	}
+    
+    
+    	{
+    		uniset_mutex m("testmutex");
+    		{
+	    		uniset_mutex_lock l(m);
+	    		msleep(20);
+	    	}
+	    	
+	    	{
+	    		uniset_mutex_lock l(m,100);
+	    		msleep(50);
+	    	}
+    		
+    	}
 #endif
 #if 0
         {
             uniset_rwmutex m1("mutex1");
             uniset_rwmutex m2("mutex2");
             uniset_rwmutex m3_lcopy("mutex3");
-
-            cout << "m1: " << m1.name() << endl;
-            cout << "m2: " << m2.name() << endl;
-            cout << "m3: " << m3_lcopy.name() << endl;
-
+            
+            cout << "m1: " << m1.name() << endl;            
+            cout << "m2: " << m2.name() << endl;            
+            cout << "m3: " << m3_lcopy.name() << endl;            
+            
             m2 = m1;
-            cout << "copy m1... m2: " << m2.name() << endl;
-
+            cout << "copy m1... m2: " << m2.name() << endl;            
+            
             m1.wrlock();
             m3_lcopy = m1;
-            cout << "copy m1... m3: " << m2.name() << endl;
+            cout << "copy m1... m3: " << m2.name() << endl;            
             cout << "m3.lock: ..." << endl;
             m3_lcopy.wrlock();
             cout << "m3.lock: wrlock OK" << endl;
         }
-
+        
         // return 0;
 #endif
 
@@ -258,7 +258,7 @@ int main( int argc, const char **argv )
         cerr << "test lock: " << ( !um.isRelease() ? "OK" : "FAIL") << endl;
     }
     cerr << "test unlock: " << (um.isRelease() ? "OK" : "FAIL") << endl;
-
+    
     {
         uniset_mutex_lock l(um);
         cerr << "test second lock: " << (!um.isRelease() ? "OK" : "FAIL") << endl;
@@ -266,20 +266,20 @@ int main( int argc, const char **argv )
         uniset_mutex_lock l2(um,500);
         cerr << "test wait lock: " << ( !l2.lock_ok() ? "OK" : "FAIL") << endl;
     }
-
+    
     uniset_mutex_lock l3(um,500);
     cerr << "test wait lock: " << ( l3.lock_ok() ? "OK" : "FAIL") << endl;
-
+    
     return 0;
 #endif
-
-
+    
+    
     int max = 10;
-
+    
     if( argc > 1 )
         max = UniSetTypes::uni_atoi(argv[1]);
 
-#if 1
+#if 1    
     typedef std::vector<MyClass*> TVec;
      TVec tvec(max);
 
@@ -291,20 +291,20 @@ int main( int argc, const char **argv )
         tvec[i] = t;
         t->execute();
         msleep(50);
-    }
+    }    
 
     cout << "TEST MUTEX LOCK wait 10 sec.. (" << tvec.size() << " threads)" << endl;
     msleep(10000);
-
+    
     cout << "TEST MUTEX LOCK RESULT: " << endl;
-
+    
     for( TVec::iterator it=tvec.begin(); it!=tvec.end(); it++ )
     {
         int c = (*it)->lock_count();
         (*it)->terminate();
         if( (*it)->get()->isRunning() )
 	        (*it)->get()->join();
-	//(*it)->get()->stop();
+       	//(*it)->get()->stop();
         cout << (*it)->name() << ": locked counter: " << (c/10) << " " << ( c!=0 ? "OK":"FAIL" ) << endl;
     }
 #endif
@@ -318,14 +318,14 @@ int main( int argc, const char **argv )
         ostringstream s;
         bool r=false;
 #if 1
-	if( i>=half )
-	{
-		r = true;
-		s << "(R)";
-	}
-	else
+    	if( i>=half )
+    	{
+    		r = true;
+    		s << "(R)";
+    	}
+    	else
 #endif
-		s << "(W)";
+    		s << "(W)";
 
         s << "t" << i;
 
@@ -364,7 +364,7 @@ int main( int argc, const char **argv )
         tsvec[i] = t;
         t->execute();
         msleep(50);
-    }
+    }   
 
 	std::atomic_int cnt(0);
 	std::atomic_int num(10);
@@ -394,7 +394,7 @@ int main( int argc, const char **argv )
     }
 
 
-#endif
+#endif    
 //    pause();
 
     }
@@ -404,7 +404,7 @@ int main( int argc, const char **argv )
         cerr << "  file: " << fe.file() << endl;
         cerr << "  line: " << fe.line() << endl;
         cerr << "  mesg: " << fe.errmsg() << endl;
-    }
+    }    
     catch( std::exception& e )
     {
         cerr << "catch: " << e.what() << endl;
@@ -413,6 +413,6 @@ int main( int argc, const char **argv )
     {
         cerr << "catch(...)" << endl;
     }
-
+    
     return 0;
 }

tests/unixml.cc

@@ -18,7 +18,7 @@ int main()
         {
             cerr << "<testnode> not found" << endl;
             return 1;
-        }
+        } 
         UniXML_iterator it(cnode);
 
         cout << "string id=" << it.getProp("id")
@@ -31,7 +31,7 @@ int main()
         {
             cerr << "<testnode> not found" << endl;
             return 1;
-        }
+        } 
 
         cout << "string id=" << it.getProp("dbrepeat")
              << " int id=" << it.getIntProp("dbrepeat")
@@ -44,13 +44,13 @@ int main()
         {
             cerr << "<testnode> not found" << endl;
             return 1;
-        }
+        } 
         UniXML_iterator it = xml.findNode(xml.getFirstNode(),"item", "LocalhostNode");
         if( it == NULL )
         {
             cerr << "<testnode> not found" << endl;
             return 1;
-        }
+        } 
         cout << "textname=" << it.getProp("textname");
                 }