backported to p8 as 2.4-alt3.M80P.4 (with rpmbph script)

TODO

@@ -7,10 +7,6 @@
 - (IONotifyController): Разработать механизм заказа группы датчиков сразу (и ответ тоже группой)
 
 ----------
-codegen:
-- Сделать работу с TestMode на основе заказа! 
-- Сделать работу с ResetMsg на основе askTimer! // подумать нужно ли..
-
 
 Version 2.3
 ============
@@ -40,10 +36,9 @@ Version 2.3
 
 - Перевести взаимодействие PassiveObject <--> ProxyManager на shared_ptr (или weak_ptr).
 
-uniset-codegen:  добавить ключ --gen-sensor-name для генерирования name_Item.. (чтобы можно было в логах использовать текстовые названия)
+uniset-codegen: добавить ключ --gen-sensor-name для генерирования name_Item.. (чтобы можно было в логах использовать текстовые названия)
 uniset-codegen: перенести инициализацию полей в header (c++11) и "разгрузить конструкторы"
 
-
 SQL:
 ====
 - добавить  работу с History (при передаче указателя на SM в конструкторе).
@@ -58,16 +53,16 @@ Version 2.5
 
 - IOBase: возможность задавать свою формулу преобразования входного сигнала (помимо калибровки)..
 
-- переписать систему инициализации и работы между UniSetActivator,UniSetManager и UniSetObject-ами
-(уменьшить количество функций (связность) и определится кто отвечает за удаление объекта и т.п.)
+- переписать систему инициализации и работы между UniSetActivator,UniSetManager и UniSetObject-ами (уменьшить количество функций (связность))
 
 
-- Использовать PIMPL
-- подумать.. это серьёзная переделка кода..
+- Использовать PIMPL (подумать.. это серьёзная переделка кода)
 
 - Вылетать с ошибкой если в секции <thresholds> указан не существующий датчик
 
 - совместимость между 64bit и 32bit - для этого нужно отказаться от использования сырого long и перейти либо на int32_t либо CORBA::Long.
+Либо стоит всё-таки ввести свой тип данных value_t для хранимых значений, чтобы спокойно работать в x86_64 и x86_32
+при этом скрыв детали реализации. А возможно в последствии наложить какие-то ограничения на этот тип
 
 - timeout_t getSharedMemoryReadyTimeout()!
 
@@ -90,8 +85,6 @@ DB: Сделать регулируемый буфер на INSERT-ы БД, чт
 Уйти от использования libcommoncpp,libxml2,DebugLog,Thread,RWLock ==> и применяять одну библиотеку libpoco (http://pocoproject.org/documentation/index.html)
 
 ==================
-Возможно стоит всё-таки ввести свой тип данных value_t для хранимых значений, чтобы спокойно работать в x86_64 и x86_32
-при этом скрыв детали реализации. А возможно в последствии наложить какие-то ограничения на этот тип
 
 Но тогда стоит вводить и namespace uniset
 =================

Utilities/codegen/ctl-cpp-common.xsl

@@ -237,13 +237,13 @@
            \param id           - идентификатор датчика
            \param showLinkName - TRUE - выводить SensorName, FALSE - не выводить
         */
-        std::string str( UniSetTypes::ObjectId id, bool showLinkName=true );
+        std::string str( UniSetTypes::ObjectId id, bool showLinkName=true ) const;
         
         /*! Вывод значения входа/выхода в формате: in_xxx(SensorName)=val 
            \param id           - идентификатор датчика
            \param showLinkName - TRUE - выводить SensorName, FALSE - не выводить
         */
-        std::string strval( UniSetTypes::ObjectId id, bool showLinkName=true );        
+        std::string strval( UniSetTypes::ObjectId id, bool showLinkName=true ) const;        
         
         /*! Вывод состояния внутренних переменных */
         inline std::string dumpVars(){ return std::move(vmon.pretty_str()); }
@@ -1184,7 +1184,7 @@ std::string  <xsl:value-of select="$CLASSNAME"/>_SK::dumpIO()
 	return std::move(s.str());
 }
 // ----------------------------------------------------------------------------
-std::string  <xsl:value-of select="$CLASSNAME"/>_SK::str( UniSetTypes::ObjectId id, bool showLinkName )
+std::string  <xsl:value-of select="$CLASSNAME"/>_SK::str( UniSetTypes::ObjectId id, bool showLinkName ) const
 {
 	ostringstream s;
 	<xsl:for-each select="//smap/item">
@@ -1198,7 +1198,7 @@ std::string  <xsl:value-of select="$CLASSNAME"/>_SK::str( UniSetTypes::ObjectId
 	return "";
 }
 // ----------------------------------------------------------------------------
-std::string  <xsl:value-of select="$CLASSNAME"/>_SK::strval( UniSetTypes::ObjectId id, bool showLinkName )
+std::string  <xsl:value-of select="$CLASSNAME"/>_SK::strval( UniSetTypes::ObjectId id, bool showLinkName ) const
 {
 	ostringstream s;
 	<xsl:for-each select="//smap/item">
@@ -1511,7 +1511,7 @@ std::string  <xsl:value-of select="$CLASSNAME"/>_SK::dumpIO()
 	return std::move(s.str());
 }
 // ----------------------------------------------------------------------------
-std::string  <xsl:value-of select="$CLASSNAME"/>_SK::str( UniSetTypes::ObjectId id, bool showLinkName )
+std::string  <xsl:value-of select="$CLASSNAME"/>_SK::str( UniSetTypes::ObjectId id, bool showLinkName ) const
 {
 	ostringstream s;
 	<xsl:for-each select="//sensors/item/consumers/consumer">
@@ -1529,7 +1529,7 @@ std::string  <xsl:value-of select="$CLASSNAME"/>_SK::str( UniSetTypes::ObjectId
 	return "";
 }
 // ----------------------------------------------------------------------------
-std::string  <xsl:value-of select="$CLASSNAME"/>_SK::strval( UniSetTypes::ObjectId id, bool showLinkName )
+std::string <xsl:value-of select="$CLASSNAME"/>_SK::strval( UniSetTypes::ObjectId id, bool showLinkName ) const
 {
 	ostringstream s;
 	<xsl:for-each select="//sensors/item/consumers/consumer">

conf/libuniset2.spec

@@ -16,7 +16,7 @@
 
 Name: libuniset2
 Version: 2.4
-Release: alt2.M80P.3
+Release: alt3.M80P.4
 Summary: UniSet - library for building distributed industrial control systems
 
 License: LGPL
@@ -486,9 +486,15 @@ mv -f %buildroot%python_sitelibdir_noarch/* %buildroot%python_sitelibdir/%oname
 # ..
 
 %changelog
-* Tue Jul 26 2016 Pavel Vainerman <pv@altlinux.ru> 2.4-alt2.M80P.3
+* Mon Aug 01 2016 Pavel Vainerman <pv@altlinux.ru> 2.4-alt3.M80P.4
 - backport to ALTLinux p8 (by rpmbph script)
 
+* Mon Aug 01 2016 Pavel Vainerman <pv@altlinux.ru> 2.4-alt4
+- build new version
+
+* Thu Jul 28 2016 Pavel Vainerman <pv@altlinux.ru> 2.4-alt3.1
+- test build
+
 * Tue Jul 26 2016 Pavel Vainerman <pv@altlinux.ru> 2.4-alt3
 - merge devel/master
 

extensions/DBServer-MySQL/MySQLInterface.h

@@ -41,7 +41,7 @@ class MySQLInterface:
 		//            DBResult listFields( const std::string& table, const std::string& wild );
 
 		virtual bool nconnect( const std::string& host, const std::string& user, const std::string& pswd,
-							   const std::string& dbname, unsigned int port=0 ) override;
+							   const std::string& dbname, unsigned int port = 0 ) override;
 		virtual bool close() override;
 
 		bool query_ok( const std::string& q );

extensions/DBServer-PostgreSQL/DBServer_PostgreSQL.cc

@@ -81,7 +81,7 @@ void DBServer_PostgreSQL::sysCommand( const UniSetTypes::SystemMessage* sm )
 	switch( sm->command )
 	{
 		case SystemMessage::StartUp:
-			askTimer(FlushInsertBuffer,ibufSyncTimeout);
+			askTimer(FlushInsertBuffer, ibufSyncTimeout);
 			break;
 
 		case SystemMessage::Finish:
@@ -199,7 +199,7 @@ void DBServer_PostgreSQL::flushInsertBuffer()
 			return;
 
 		dbcrit << myname << "(flushWriteBuffer): DB not connected!"
-				<< " buffer[" << ibufSize << "] overflow! LOST DATA..." << endl;
+			   << " buffer[" << ibufSize << "] overflow! LOST DATA..." << endl;
 
 		// Чистим заданное число
 		size_t delnum = lroundf(ibufSize * ibufOverflowCleanFactor);
@@ -219,8 +219,9 @@ void DBServer_PostgreSQL::flushInsertBuffer()
 			std::advance(end, delnum);
 		}
 
-		ibuf.erase(beg,end);
+		ibuf.erase(beg, end);
 		ibufSize -= delnum;
+
 		if( ibufSize < 0 )
 			ibufSize = 0;
 
@@ -233,7 +234,7 @@ void DBServer_PostgreSQL::flushInsertBuffer()
 
 	dbinfo << myname << "(flushInsertBuffer): write insert buffer[" << ibufSize << "] to DB.." << endl;
 
-	if( !db->copy("main_history",tblcols,ibuf) )
+	if( !db->copy("main_history", tblcols, ibuf) )
 	{
 		dbcrit << myname << "(flushInsertBuffer): error: " << db->error() << endl;
 	}
@@ -322,20 +323,20 @@ void DBServer_PostgreSQL::initDBServer()
 	string dbnode( conf->getArgParam("--" + prefix + "-dbnode", it.getProp("dbnode")));
 	string dbuser( conf->getArgParam("--" + prefix + "-dbuser", it.getProp("dbuser")));
 	string dbpass( conf->getArgParam("--" + prefix + "-dbpass", it.getProp("dbpass")));
-	unsigned int dbport = conf->getArgPInt("--" + prefix + "-dbport", it.getProp("dbport"),5432);
+	unsigned int dbport = conf->getArgPInt("--" + prefix + "-dbport", it.getProp("dbport"), 5432);
 
-	ibufMaxSize = conf->getArgPInt("--" + prefix + "-ibuf-maxsize", it.getProp("ibufMaxSize"),2000);
+	ibufMaxSize = conf->getArgPInt("--" + prefix + "-ibuf-maxsize", it.getProp("ibufMaxSize"), 2000);
 	ibuf.reserve(ibufMaxSize);
 
-	ibufSyncTimeout = conf->getArgPInt("--" + prefix + "-ibuf-sync-timeout", it.getProp("ibufSyncTimeout"),15000);
-	std::string sfactor = conf->getArg2Param("--" + prefix + "-ibuf-overflow-cleanfactor", it.getProp("ibufOverflowCleanFactor"),"0.5");
+	ibufSyncTimeout = conf->getArgPInt("--" + prefix + "-ibuf-sync-timeout", it.getProp("ibufSyncTimeout"), 15000);
+	std::string sfactor = conf->getArg2Param("--" + prefix + "-ibuf-overflow-cleanfactor", it.getProp("ibufOverflowCleanFactor"), "0.5");
 	ibufOverflowCleanFactor = atof(sfactor.c_str());
 
 	tblMap[UniSetTypes::Message::SensorInfo] = "main_history";
 	tblMap[UniSetTypes::Message::Confirm] = "main_history";
 
-	PingTime = conf->getArgPInt("--" + prefix + "-pingTime", it.getProp("pingTime"),15000);
-	ReconnectTime = conf->getArgPInt("--" + prefix + "-reconnectTime", it.getProp("reconnectTime"),30000);
+	PingTime = conf->getArgPInt("--" + prefix + "-pingTime", it.getProp("pingTime"), 15000);
+	ReconnectTime = conf->getArgPInt("--" + prefix + "-reconnectTime", it.getProp("reconnectTime"), 30000);
 
 	qbufSize = conf->getArgPInt("--" + prefix + "-buffer-size", it.getProp("bufferSize"), 200);
 

extensions/DBServer-PostgreSQL/DBServer_PostgreSQL.h

@@ -114,7 +114,7 @@ class DBServer_PostgreSQL:
 		std::mutex mqbuf;
 
 		// writeBuffer
-		const std::list<std::string> tblcols = { "date", "time","time_usec","sensor_id","value","node" };
+		const std::list<std::string> tblcols = { "date", "time", "time_usec", "sensor_id", "value", "node" };
 
 		typedef std::vector<PostgreSQLInterface::Record> InsertBuffer;
 		InsertBuffer ibuf;

extensions/DBServer-PostgreSQL/PostgreSQLInterface.cc

@@ -98,11 +98,12 @@ bool PostgreSQLInterface::copy( const std::string& tblname, const std::list<std:
 	try
 	{
 		work w( *(db.get()) );
-		tablewriter t(w,tblname,cols.begin(),cols.end());
+		tablewriter t(w, tblname, cols.begin(), cols.end());
 
 		t.reserve(data.size()); // size() не дорогая операция для list?
-		for( const auto& d: data )
-			t.push_back(d.begin(),d.end());
+
+		for( const auto& d : data )
+			t.push_back(d.begin(), d.end());
 
 		t.complete();
 		w.commit();

extensions/DBServer-PostgreSQL/PostgreSQLInterface.h

@@ -36,7 +36,7 @@ class PostgreSQLInterface:
 
 		virtual bool nconnect( const std::string& host, const std::string& user,
 							   const std::string& pswd, const std::string& dbname,
-							   unsigned int port=5432) override;
+							   unsigned int port = 5432) override;
 		virtual bool close() override;
 		virtual bool isConnection() override;
 		virtual bool ping() override; // проверка доступности БД

extensions/DBServer-PostgreSQL/test.cc

@@ -14,17 +14,19 @@ int main(int argc, char** argv)
 		dbname = string(argv[1]);
 
 	size_t ver = 1;
+
 	if( argc > 2 )
 		ver = atoi(argv[2]);
 
 	size_t num = 10000;
+
 	if( argc > 3 )
 		num = atoi(argv[3]);
 
 	try
 	{
 		PostgreSQLInterface db;
-		
+
 		cout << "connect to '" << dbname << "'..." << endl;
 
 		if( !db.nconnect("localhost", "dbadmin", "dbadmin", dbname) )
@@ -40,7 +42,7 @@ int main(int argc, char** argv)
 
 		if( ver == 1 )
 		{
-			for( size_t i=0; i<num; i++ )
+			for( size_t i = 0; i < num; i++ )
 			{
 				q << "INSERT INTO main_history(date,time,time_usec,sensor_id,value,node)"
 				  << " VALUES(now(),now(),0,7,1,3000);";
@@ -49,7 +51,8 @@ int main(int argc, char** argv)
 		else if( ver == 2 )
 		{
 			q << "INSERT INTO main_history(date,time,time_usec,sensor_id,value,node) VALUES";
-			for( size_t i=0; i<num; i++ )
+
+			for( size_t i = 0; i < num; i++ )
 			{
 				q << "(now(),now(),0,7,1,3000),";
 			}
@@ -58,18 +61,21 @@ int main(int argc, char** argv)
 		}
 
 		std::chrono::time_point<std::chrono::system_clock> start, end;
+
 		if( ver == 3 )
 		{
-			std::list<std::string> cols = { "date", "time","time_usec","sensor_id","value","node" };
+			std::list<std::string> cols = { "date", "time", "time_usec", "sensor_id", "value", "node" };
 			PostgreSQLInterface::Data data;
-			for( size_t i=0; i<num; i++ )
+
+			for( size_t i = 0; i < num; i++ )
 			{
-				PostgreSQLInterface::Record d = { "now()","now()","0","7","1","3000" };
+				PostgreSQLInterface::Record d = { "now()", "now()", "0", "7", "1", "3000" };
 				data.push_back(std::move(d));
 			}
 
 			start = std::chrono::system_clock::now();
-			if( !db.copy("main_history",cols,data) )
+
+			if( !db.copy("main_history", cols, data) )
 			{
 				cerr << "query error: " << db.error() << endl;
 				db.close();
@@ -79,6 +85,7 @@ int main(int argc, char** argv)
 		else
 		{
 			start = std::chrono::system_clock::now();
+
 			if( !db.insert( std::move(q.str())) )
 			{
 				cerr << "query error: " << db.error() << endl;

extensions/IOControl/ComediInterface.h

@@ -62,8 +62,7 @@ class ComediInterface
 		static std::string type2str( SubdevType t );
 		static SubdevType str2type( const std::string& s );
 
-		void configureSubdev( int subdev, SubdevType type )    throw(UniSetTypes::Exception);
-
+		void configureSubdev( int subdev, SubdevType type ) throw(UniSetTypes::Exception);
 
 		void configureChannel( int subdev, int channel, ChannelType type, int range = 0, int aref = 0 )
 		throw(UniSetTypes::Exception);

extensions/IOControl/IOControl.h

@@ -186,15 +186,15 @@ class CardList:
 {
 	public:
 
-		explicit CardList( int size ) : std::vector<ComediInterface * >(size) { }
+		explicit CardList( size_t size ) : std::vector<ComediInterface * >(size) { }
 
 		~CardList()
 		{
-			for( unsigned int i = 0; i < size(); i++ )
+			for( size_t i = 0; i < size(); i++ )
 				delete (*this)[i];
 		}
 
-		inline ComediInterface* getCard(int ncard)
+		inline ComediInterface* getCard(int ncard) const
 		{
 			if( ncard >= 0 && ncard < (int)size() )
 				return (*this)[ncard];
@@ -258,7 +258,7 @@ class IOControl:
 
 			int subdev;     /*!< (UNIO) подустройство (см. comedi_test для конкретной карты в/в) */
 			int channel;    /*!< (UNIO) канал [0...23] */
-			int ncard;      /*!< номер карты [1|2]. 0 - не определена. FIXME from Lav: -1 - не определена? */
+			int ncard;      /*!< номер карты [1|2]. -1 - не определена. */
 
 			/*! Вид поключения
 			    0    - analog ref = analog ground
@@ -286,21 +286,21 @@ class IOControl:
 
 		struct IOPriority
 		{
-			IOPriority(int p, int i):
+			IOPriority(size_t  p, size_t i):
 				priority(p), index(i) {}
 
-			int priority;
-			int index;
+			size_t  priority;
+			size_t index;
 		};
 
 		enum TestModeID
 		{
-			tmNone        = 0,       /*!< тестовый режим отключён */
+			tmNone       = 0,       /*!< тестовый режим отключён */
 			tmOffPoll    = 1,        /*!< отключить опрос */
-			tmConfigEnable    = 2,   /*!< специальный режим, в соответсвии с настройкой 'enable_testmode' */
-			tmConfigDisable    = 3,  /*!< специальный режим, в соответсвии с настройкой 'disable_testmode' */
+			tmConfigEnable  = 2,   /*!< специальный режим, в соответствии с настройкой 'enable_testmode' */
+			tmConfigDisable = 3,  /*!< специальный режим, в соответствии с настройкой 'disable_testmode' */
 			tmOnlyInputs    = 4,     /*!< включены только входы */
-			tmOnlyOutputs    = 5     /*!< включены только выходы */
+			tmOnlyOutputs   = 5     /*!< включены только выходы */
 		};
 
 		void execute();
@@ -335,8 +335,6 @@ class IOControl:
 
 		void waitSM();
 
-		bool checkCards( const std::string& func = "" );
-
 		xmlNode* cnode = { 0 }; /*!< xml-узел в настроечном файле */
 
 		int polltime = { 150 };   /*!< переодичность обновления данных (опроса карт в/в), [мсек] */
@@ -403,8 +401,7 @@ class IOControl:
 		bool readconf_ok = { false };
 		int activateTimeout;
 		UniSetTypes::ObjectId sidTestSMReady = { UniSetTypes::DefaultObjectId };
-		bool term = { false };
-
+		std::atomic_bool term = { false };
 
 		UniSetTypes::ObjectId testMode_as = { UniSetTypes::DefaultObjectId };
 		IOController::IOStateList::iterator itTestMode;

extensions/LogicProcessor/Element.cc

@@ -23,7 +23,7 @@ using namespace std;
 const Element::ElementID Element::DefaultElementID = "?id?";
 // -------------------------------------------------------------------------
 
-void Element::addChildOut( std::shared_ptr<Element> el, int num )
+void Element::addChildOut( std::shared_ptr<Element> el, size_t num )
 {
 	if( el.get() == this )
 	{
@@ -90,7 +90,7 @@ std::shared_ptr<Element> Element::find(const ElementID& id )
 	return nullptr;
 }
 // -------------------------------------------------------------------------
-void Element::addInput(int num, bool state)
+void Element::addInput(size_t num, bool state)
 {
 	for( auto& it : ins )
 	{
@@ -105,7 +105,7 @@ void Element::addInput(int num, bool state)
 	ins.push_front(InputInfo(num, state));
 }
 // -------------------------------------------------------------------------
-void Element::delInput( int num )
+void Element::delInput(size_t num )
 {
 	for( auto it = ins.begin(); it != ins.end(); ++it )
 	{

extensions/LogicProcessor/Element.h

@@ -57,30 +57,30 @@ class Element
 		*/
 		virtual void tick() {}
 
-		virtual void setIn( int num, bool state ) = 0;
-		virtual bool getOut() = 0;
+		virtual void setIn( size_t num, bool state ) = 0;
+		virtual bool getOut() const = 0;
 
-		inline ElementID getId()
+		inline ElementID getId() const
 		{
 			return myid;
 		}
-		virtual std::string getType()
+		virtual std::string getType() const
 		{
 			return "?type?";
 		}
 
 		virtual std::shared_ptr<Element> find( const ElementID& id );
 
-		virtual void addChildOut( std::shared_ptr<Element> el, int in_num );
+		virtual void addChildOut( std::shared_ptr<Element> el, size_t in_num );
 		virtual void delChildOut( std::shared_ptr<Element> el );
-		inline int outCount()
+		inline size_t outCount() const
 		{
 			return outs.size();
 		}
 
-		virtual void addInput( int num, bool state = false );
-		virtual void delInput( int num );
-		inline  int inCount()
+		virtual void addInput( size_t num, bool state = false );
+		virtual void delInput( size_t num );
+		inline size_t inCount() const
 		{
 			return ins.size();
 		}
@@ -103,24 +103,23 @@ class Element
 
 		struct ChildInfo
 		{
-			ChildInfo(std::shared_ptr<Element> e, int n):
+			ChildInfo(std::shared_ptr<Element> e, size_t n):
 				el(e), num(n) {}
 			ChildInfo(): el(0), num(0) {}
 
 			std::shared_ptr<Element> el;
-			int num;
+			size_t num;
 		};
 
 		typedef std::list<ChildInfo> OutputList;
 		OutputList outs;
 		virtual void setChildOut();
 
-
 		struct InputInfo
 		{
 			InputInfo(): num(0), state(false), type(unknown) {}
-			InputInfo(int n, bool s): num(n), state(s), type(unknown) {}
-			int num;
+			InputInfo(size_t n, bool s): num(n), state(s), type(unknown) {}
+			size_t num;
 			bool state;
 			InputType type;
 		};
@@ -140,16 +139,16 @@ class TOR:
 {
 
 	public:
-		TOR( ElementID id, unsigned int numbers = 0, bool st = false );
+		TOR( ElementID id, size_t numbers = 0, bool st = false );
 		virtual ~TOR();
 
-		virtual void setIn( int num, bool state ) override;
-		virtual bool getOut() override
+		virtual void setIn( size_t num, bool state ) override;
+		virtual bool getOut() const override
 		{
 			return myout;
 		}
 
-		virtual std::string getType() override
+		virtual std::string getType() const override
 		{
 			return "OR";
 		}
@@ -167,11 +166,11 @@ class TAND:
 {
 
 	public:
-		TAND( ElementID id, int numbers = 0, bool st = false );
+		TAND(ElementID id, size_t numbers = 0, bool st = false );
 		virtual ~TAND();
 
-		virtual void setIn( int num, bool state ) override;
-		virtual std::string getType() override
+		virtual void setIn( size_t num, bool state ) override;
+		virtual std::string getType() const override
 		{
 			return "AND";
 		}
@@ -192,20 +191,20 @@ class TNOT:
 		TNOT( ElementID id, bool out_default );
 		virtual ~TNOT();
 
-		virtual bool getOut() override
+		virtual bool getOut() const override
 		{
 			return myout;
 		}
 
 		/* num игнорируется, т.к. элемент с одним входом
 		 */
-		virtual void setIn( int num, bool state ) override ;
-		virtual std::string getType() override
+		virtual void setIn( size_t num, bool state ) override ;
+		virtual std::string getType() const override
 		{
 			return "NOT";
 		}
-		virtual void addInput( int num, bool state = false ) override {}
-		virtual void delInput( int num ) override {}
+		virtual void addInput( size_t num, bool state = false ) override {}
+		virtual void delInput( size_t num ) override {}
 
 	protected:
 		TNOT(): myout(false) {}

extensions/LogicProcessor/LProcessor.h

@@ -116,7 +116,7 @@ class LProcessor
 
 		void open( const std::string& lfile );
 
-		inline bool isOpen()
+		inline bool isOpen() const
 		{
 			return !fSchema.empty();
 		}
@@ -133,7 +133,7 @@ class LProcessor
 			return sch;
 		}
 
-		inline int getSleepTime()
+		inline int getSleepTime() const
 		{
 			return sleepTime;
 		}

extensions/LogicProcessor/TAND.cc

@@ -21,7 +21,7 @@
 using namespace std;
 using namespace UniSetExtensions;
 // -------------------------------------------------------------------------
-TAND::TAND(ElementID id, int num, bool st):
+TAND::TAND(ElementID id, size_t num, bool st):
 	TOR(id, num, st)
 {
 }
@@ -30,7 +30,7 @@ TAND::~TAND()
 {
 }
 // -------------------------------------------------------------------------
-void TAND::setIn( int num, bool state )
+void TAND::setIn(size_t num, bool state )
 {
 	//    cout << this << ": input " << num << " set " << state << endl;
 	for( auto& it : ins )

extensions/LogicProcessor/TDelay.cc

@@ -21,7 +21,7 @@
 using namespace std;
 using namespace UniSetExtensions;
 // -------------------------------------------------------------------------
-TDelay::TDelay( Element::ElementID id, timeout_t delayMS, unsigned int inCount):
+TDelay::TDelay(Element::ElementID id, timeout_t delayMS, size_t inCount):
 	Element(id),
 	myout(false),
 	delay(delayMS)
@@ -38,7 +38,7 @@ TDelay::~TDelay()
 {
 }
 // -------------------------------------------------------------------------
-void TDelay::setIn( int num, bool state )
+void TDelay::setIn( size_t num, bool state )
 {
 	bool prev = myout;
 
@@ -89,7 +89,7 @@ void TDelay::tick()
 	}
 }
 // -------------------------------------------------------------------------
-bool TDelay::getOut()
+bool TDelay::getOut() const
 {
 	return myout;
 }

extensions/LogicProcessor/TDelay.h

@@ -27,14 +27,13 @@ class TDelay:
 {
 
 	public:
-		TDelay( Element::ElementID id, timeout_t delayMS = 0, unsigned int inCount = 0 );
+		TDelay( Element::ElementID id, timeout_t delayMS = 0, size_t inCount = 0 );
 		virtual ~TDelay();
 
-
 		virtual void tick() override;
-		virtual void setIn( int num, bool state ) override;
-		virtual bool getOut() override;
-		virtual std::string getType() override
+		virtual void setIn( size_t num, bool state ) override;
+		virtual bool getOut() const override;
+		virtual std::string getType() const override
 		{
 			return "Delay";
 		}

extensions/LogicProcessor/TNOT.cc

@@ -33,7 +33,7 @@ TNOT::~TNOT()
 {
 }
 // -------------------------------------------------------------------------
-void TNOT::setIn( int num, bool state )
+void TNOT::setIn( size_t num, bool state )
 {
 	bool prev = myout;
 	myout = !state;

extensions/LogicProcessor/TOR.cc

@@ -22,7 +22,7 @@
 using namespace std;
 using namespace UniSetExtensions;
 // -------------------------------------------------------------------------
-TOR::TOR(ElementID id, unsigned int num, bool st):
+TOR::TOR(ElementID id, size_t num, bool st):
 	Element(id),
 	myout(false)
 {
@@ -43,7 +43,7 @@ TOR::~TOR()
 {
 }
 // -------------------------------------------------------------------------
-void TOR::setIn( int num, bool state )
+void TOR::setIn( size_t num, bool state )
 {
 	//    cout << getType() << "(" << myid << "):  input " << num << " set " << state << endl;
 

extensions/ModbusMaster/MBExchange.cc

@@ -327,7 +327,7 @@ void MBExchange::step()
 }
 
 // -----------------------------------------------------------------------------
-bool MBExchange::checkProcActive()
+bool MBExchange::checkProcActive() const
 {
 	return activated;
 }
@@ -509,7 +509,7 @@ bool MBExchange::checkUpdateSM( bool wrFunc, long mdev )
 	return true;
 }
 // -----------------------------------------------------------------------------
-bool MBExchange::checkPoll( bool wrFunc )
+bool MBExchange::checkPoll( bool wrFunc ) const
 {
 	if( exchangeMode == emWriteOnly && !wrFunc )
 	{
@@ -1463,14 +1463,14 @@ void MBExchange::updateRSProperty( RSProperty* p, bool write_only )
 					{
 						VTypes::F2 f2(f);
 
-						for( int k = 0; k < VTypes::F2::wsize(); k++, i++ )
+						for( size_t k = 0; k < VTypes::F2::wsize(); k++, i++ )
 							i->second->mbval = f2.raw.v[k];
 					}
 					else if( p->vType == VTypes::vtF2r )
 					{
 						VTypes::F2r f2(f);
 
-						for( int k = 0; k < VTypes::F2r::wsize(); k++, i++ )
+						for( size_t k = 0; k < VTypes::F2r::wsize(); k++, i++ )
 							i->second->mbval = f2.raw.v[k];
 					}
 
@@ -1481,7 +1481,7 @@ void MBExchange::updateRSProperty( RSProperty* p, bool write_only )
 			{
 				ModbusRTU::ModbusData* data = new ModbusRTU::ModbusData[VTypes::F2::wsize()];
 
-				for( int k = 0; k < VTypes::F2::wsize(); k++, i++ )
+				for( size_t k = 0; k < VTypes::F2::wsize(); k++, i++ )
 					data[k] = i->second->mbval;
 
 				float f = 0;
@@ -1513,7 +1513,7 @@ void MBExchange::updateRSProperty( RSProperty* p, bool write_only )
 					float f = IOBase::processingFasAO( p, shm, force_out );
 					VTypes::F4 f4(f);
 
-					for( int k = 0; k < VTypes::F4::wsize(); k++, i++ )
+					for( size_t k = 0; k < VTypes::F4::wsize(); k++, i++ )
 						i->second->mbval = f4.raw.v[k];
 
 					r->sm_initOK = true;
@@ -1523,7 +1523,7 @@ void MBExchange::updateRSProperty( RSProperty* p, bool write_only )
 			{
 				ModbusRTU::ModbusData* data = new ModbusRTU::ModbusData[VTypes::F4::wsize()];
 
-				for( int k = 0; k < VTypes::F4::wsize(); k++, i++ )
+				for( size_t k = 0; k < VTypes::F4::wsize(); k++, i++ )
 					data[k] = i->second->mbval;
 
 				VTypes::F4 f(data, VTypes::F4::wsize());
@@ -1546,14 +1546,14 @@ void MBExchange::updateRSProperty( RSProperty* p, bool write_only )
 					{
 						VTypes::I2 i2(v);
 
-						for( int k = 0; k < VTypes::I2::wsize(); k++, i++ )
+						for( size_t k = 0; k < VTypes::I2::wsize(); k++, i++ )
 							i->second->mbval = i2.raw.v[k];
 					}
 					else if( p->vType == VTypes::vtI2r )
 					{
 						VTypes::I2r i2(v);
 
-						for( int k = 0; k < VTypes::I2::wsize(); k++, i++ )
+						for( size_t k = 0; k < VTypes::I2::wsize(); k++, i++ )
 							i->second->mbval = i2.raw.v[k];
 					}
 
@@ -1564,7 +1564,7 @@ void MBExchange::updateRSProperty( RSProperty* p, bool write_only )
 			{
 				ModbusRTU::ModbusData* data = new ModbusRTU::ModbusData[VTypes::I2::wsize()];
 
-				for( int k = 0; k < VTypes::I2::wsize(); k++, i++ )
+				for( size_t k = 0; k < VTypes::I2::wsize(); k++, i++ )
 					data[k] = i->second->mbval;
 
 				int v = 0;
@@ -1598,14 +1598,14 @@ void MBExchange::updateRSProperty( RSProperty* p, bool write_only )
 					{
 						VTypes::U2 u2(v);
 
-						for( int k = 0; k < VTypes::U2::wsize(); k++, i++ )
+						for( size_t k = 0; k < VTypes::U2::wsize(); k++, i++ )
 							i->second->mbval = u2.raw.v[k];
 					}
 					else if( p->vType == VTypes::vtU2r )
 					{
 						VTypes::U2r u2(v);
 
-						for( int k = 0; k < VTypes::U2::wsize(); k++, i++ )
+						for( size_t k = 0; k < VTypes::U2::wsize(); k++, i++ )
 							i->second->mbval = u2.raw.v[k];
 					}
 
@@ -1616,7 +1616,7 @@ void MBExchange::updateRSProperty( RSProperty* p, bool write_only )
 			{
 				ModbusRTU::ModbusData* data = new ModbusRTU::ModbusData[VTypes::U2::wsize()];
 
-				for( int k = 0; k < VTypes::U2::wsize(); k++, i++ )
+				for( size_t k = 0; k < VTypes::U2::wsize(); k++, i++ )
 					data[k] = i->second->mbval;
 
 				unsigned int v = 0;

extensions/ModbusMaster/MBExchange.h

@@ -301,9 +301,9 @@ class MBExchange:
 		virtual void updateRespondSensors();
 
 		bool checkUpdateSM( bool wrFunc, long devMode );
-		bool checkPoll( bool wrFunc );
+		bool checkPoll( bool wrFunc ) const;
 
-		bool checkProcActive();
+		bool checkProcActive() const;
 		void setProcActive( bool st );
 		void waitSMReady();
 

extensions/ModbusMaster/MBTCPMultiMaster.cc

@@ -316,7 +316,7 @@ void MBTCPMultiMaster::final_thread()
 }
 // -----------------------------------------------------------------------------
 
-bool MBTCPMultiMaster::MBSlaveInfo::check()
+bool MBTCPMultiMaster::MBSlaveInfo::check() const
 {
 	return mbtcp->checkConnection(ip, port, recv_timeout);
 }

extensions/ModbusMaster/MBTCPMultiMaster.h

@@ -302,7 +302,7 @@ class MBTCPMultiMaster:
 			}
 
 			bool init( std::shared_ptr<DebugStream>& mblog );
-			bool check();
+			bool check() const;
 			inline void setUse( bool st )
 			{
 				respond_init = !( st && !use );

extensions/ModbusSlave/MBSlave.cc

@@ -1771,7 +1771,7 @@ ModbusRTU::mbErrCode MBSlave::real_write_prop( IOProperty* p, ModbusRTU::ModbusD
 
 			ModbusRTU::ModbusData* d = new ModbusRTU::ModbusData[VTypes::I2::wsize()];
 
-			for( int k = 0; k < VTypes::I2::wsize(); k++, i++ )
+			for( size_t k = 0; k < VTypes::I2::wsize(); k++, i++ )
 				d[k] = dat[i];
 
 			VTypes::I2 i2(d, VTypes::I2::wsize());
@@ -1788,7 +1788,7 @@ ModbusRTU::mbErrCode MBSlave::real_write_prop( IOProperty* p, ModbusRTU::ModbusD
 
 			ModbusRTU::ModbusData* d = new ModbusRTU::ModbusData[VTypes::I2r::wsize()];
 
-			for( int k = 0; k < VTypes::I2r::wsize(); k++, i++ )
+			for( size_t k = 0; k < VTypes::I2r::wsize(); k++, i++ )
 				d[k] = dat[i];
 
 			VTypes::I2r i2r(d, VTypes::I2r::wsize());
@@ -1805,7 +1805,7 @@ ModbusRTU::mbErrCode MBSlave::real_write_prop( IOProperty* p, ModbusRTU::ModbusD
 
 			ModbusRTU::ModbusData* d = new ModbusRTU::ModbusData[VTypes::U2::wsize()];
 
-			for( int k = 0; k < VTypes::U2::wsize(); k++, i++ )
+			for( size_t k = 0; k < VTypes::U2::wsize(); k++, i++ )
 				d[k] = dat[i];
 
 			VTypes::U2 u2(d, VTypes::U2::wsize());
@@ -1822,7 +1822,7 @@ ModbusRTU::mbErrCode MBSlave::real_write_prop( IOProperty* p, ModbusRTU::ModbusD
 
 			ModbusRTU::ModbusData* d = new ModbusRTU::ModbusData[VTypes::U2r::wsize()];
 
-			for( int k = 0; k < VTypes::U2r::wsize(); k++, i++ )
+			for( size_t k = 0; k < VTypes::U2r::wsize(); k++, i++ )
 				d[k] = dat[i];
 
 			VTypes::U2r u2r(d, VTypes::U2r::wsize());
@@ -1839,7 +1839,7 @@ ModbusRTU::mbErrCode MBSlave::real_write_prop( IOProperty* p, ModbusRTU::ModbusD
 
 			ModbusRTU::ModbusData* d = new ModbusRTU::ModbusData[VTypes::F2::wsize()];
 
-			for( int k = 0; k < VTypes::F2::wsize(); k++, i++ )
+			for( size_t k = 0; k < VTypes::F2::wsize(); k++, i++ )
 				d[k] = dat[i];
 
 			VTypes::F2 f2(d, VTypes::F2::wsize());
@@ -1857,7 +1857,7 @@ ModbusRTU::mbErrCode MBSlave::real_write_prop( IOProperty* p, ModbusRTU::ModbusD
 
 			ModbusRTU::ModbusData* d = new ModbusRTU::ModbusData[VTypes::F2r::wsize()];
 
-			for( int k = 0; k < VTypes::F2r::wsize(); k++, i++ )
+			for( size_t k = 0; k < VTypes::F2r::wsize(); k++, i++ )
 				d[k] = dat[i];
 
 			VTypes::F2r f2r(d, VTypes::F2r::wsize());
@@ -1874,7 +1874,7 @@ ModbusRTU::mbErrCode MBSlave::real_write_prop( IOProperty* p, ModbusRTU::ModbusD
 
 			ModbusRTU::ModbusData* d = new ModbusRTU::ModbusData[VTypes::F4::wsize()];
 
-			for( int k = 0; k < VTypes::F4::wsize(); k++, i++ )
+			for( size_t k = 0; k < VTypes::F4::wsize(); k++, i++ )
 				d[k] = dat[i];
 
 			VTypes::F4 f4(d, VTypes::F4::wsize());

extensions/SharedMemory/SharedMemory.cc

@@ -984,6 +984,7 @@ UniSetTypes::SimpleInfo* SharedMemory::getInfo( CORBA::Long userparam )
 
 	inf << i->info << endl;
 	inf << vmon.pretty_str() << endl;
+
 	if( logserv )
 		inf << logserv->getShortInfo() << endl;
 	else

extensions/UNetUDP/UDPPacket.cc

@@ -317,7 +317,7 @@ size_t UDPMessage::getMessage( UDPMessage& m, UDPPacket& p )
 	return i + sz;
 }
 // -----------------------------------------------------------------------------
-uint16_t UDPMessage::getDataCRC()
+uint16_t UDPMessage::getDataCRC() const
 {
 	uint16_t crc[3];
 	crc[0] = makeCRC( (unsigned char*)(a_dat), sizeof(a_dat) );

extensions/UNetUDP/UDPPacket.h

@@ -37,17 +37,16 @@ namespace UniSetUDP
 		т.к. это не сильно актуально, пока не переделываю.
 	*/
 
-	const unsigned int UNETUDP_MAGICNUM = 0x1337A1D; // идентификатор протокола
+	const uint32_t UNETUDP_MAGICNUM = 0x1337A1D; // идентификатор протокола
 
 	struct UDPHeader
 	{
 		UDPHeader(): magic(UNETUDP_MAGICNUM), num(0), nodeID(0), procID(0), dcount(0), acount(0) {}
-		unsigned int magic;
+		uint32_t magic;
 		size_t num;
 		long nodeID;
 		long procID;
 
-		//!\todo может лучше использовать системно-независимый unsigned long, чем size_t?
 		size_t dcount; /*!< количество булевых величин */
 		size_t acount; /*!< количество аналоговых величин */
 
@@ -129,7 +128,7 @@ namespace UniSetUDP
 			return acount;
 		}
 
-		uint16_t getDataCRC();
+		uint16_t getDataCRC() const;
 
 		// количество байт в пакете с булевыми переменными...
 		size_t d_byte() const

extensions/include/MTR.h

@@ -54,7 +54,7 @@ namespace MTR
 	// -------------------------------------------------------------------------
 	std::string type2str( MTRType t );          /*!< преоразование строки в тип */
 	MTRType str2type( const std::string& s );   /*!< преобразование названия в строку */
-	int wsize( MTRType t );                     /*!< длина данных в словах */
+	size_t wsize( MTRType t );                     /*!< длина данных в словах */
 	// -------------------------------------------------------------------------
 	// Информация
 	const ModbusRTU::ModbusData regModelNumber  = 0x01;
@@ -129,7 +129,7 @@ namespace MTR
 	void update_communication_params( ModbusRTU::ModbusAddr reg, ModbusRTU::ModbusData data,
 									  ModbusRTUMaster* mb, ModbusRTU::ModbusAddr& addr, int verb );
 	// -------------------------------------------------------------------------
-	static const int u2size = 2;
+	static const size_t u2size = 2;
 	// -------------------------------------------------------------------------
 	class T1
 	{
@@ -140,7 +140,7 @@ namespace MTR
 			~T1() {}
 			// ------------------------------------------
 			/*! размер в словах */
-			static unsigned int wsize()
+			static size_t wsize()
 			{
 				return 1;
 			}
@@ -163,7 +163,7 @@ namespace MTR
 			~T2() {}
 			// ------------------------------------------
 			/*! размер в словах */
-			static unsigned int wsize()
+			static size_t wsize()
 			{
 				return 1;
 			}
@@ -205,7 +205,7 @@ namespace MTR
 				raw.v[1] = v2;
 			}
 
-			T3( const ModbusRTU::ModbusData* data, int size )
+			T3( const ModbusRTU::ModbusData* data, size_t size )
 			{
 				if( size >= u2size )
 				{
@@ -218,7 +218,7 @@ namespace MTR
 			~T3() {}
 			// ------------------------------------------
 			/*! размер в словах */
-			static unsigned int wsize()
+			static size_t wsize()
 			{
 				return u2size;
 			}
@@ -262,7 +262,7 @@ namespace MTR
 			~T4() {}
 			// ------------------------------------------
 			/*! размер в словах */
-			static unsigned int wsize()
+			static size_t wsize()
 			{
 				return 1;
 			}
@@ -311,7 +311,7 @@ namespace MTR
 				val = raw.u2.val * pow( (long)10, (long)raw.u2.exp );
 			}
 
-			T5( const ModbusRTU::ModbusData* data, int size ): val(0)
+			T5( const ModbusRTU::ModbusData* data, size_t size ): val(0)
 			{
 				if( size >= u2size )
 				{
@@ -325,7 +325,7 @@ namespace MTR
 			~T5() {}
 			// ------------------------------------------
 			/*! размер в словах */
-			static unsigned int wsize()
+			static size_t wsize()
 			{
 				return u2size;
 			}
@@ -374,7 +374,7 @@ namespace MTR
 				val = raw.u2.val * pow( (long)10, (long)raw.u2.exp );
 			}
 
-			T6( const ModbusRTU::ModbusData* data, int size )
+			T6( const ModbusRTU::ModbusData* data, size_t size )
 			{
 				if( size >= u2size )
 				{
@@ -388,7 +388,7 @@ namespace MTR
 			~T6() {}
 			// ------------------------------------------
 			/*! размер в словах */
-			static unsigned int wsize()
+			static size_t wsize()
 			{
 				return u2size;
 			}
@@ -437,7 +437,7 @@ namespace MTR
 				val = raw.u2.val * pow( (long)10, (long) - 4 );
 			}
 
-			T7( const ModbusRTU::ModbusData* data, int size )
+			T7( const ModbusRTU::ModbusData* data, size_t size )
 			{
 				if( size >= u2size )
 				{
@@ -451,7 +451,7 @@ namespace MTR
 			~T7() {}
 			// ------------------------------------------
 			/*! размер в словах */
-			static unsigned int wsize()
+			static size_t wsize()
 			{
 				return u2size;
 			}
@@ -494,7 +494,7 @@ namespace MTR
 				raw.v[1] = v2;
 			}
 
-			T8( const ModbusRTU::ModbusData* data, int size )
+			T8( const ModbusRTU::ModbusData* data, size_t size )
 			{
 				if( size >= u2size )
 				{
@@ -524,7 +524,7 @@ namespace MTR
 			~T8() {}
 			// ------------------------------------------
 			/*! размер в словах */
-			static unsigned int wsize()
+			static size_t wsize()
 			{
 				return u2size;
 			}
@@ -566,7 +566,7 @@ namespace MTR
 				raw.v[1] = v2;
 			}
 
-			T9( const ModbusRTU::ModbusData* data, int size )
+			T9( const ModbusRTU::ModbusData* data, size_t size )
 			{
 				if( size >= u2size )
 				{
@@ -596,7 +596,7 @@ namespace MTR
 			~T9() {}
 			// ------------------------------------------
 			/*! размер в словах */
-			static unsigned int wsize()
+			static size_t wsize()
 			{
 				return u2size;
 			}
@@ -637,7 +637,7 @@ namespace MTR
 				raw.v[1] = v2;
 			}
 
-			T10( const ModbusRTU::ModbusData* data, int size )
+			T10( const ModbusRTU::ModbusData* data, size_t size )
 			{
 				if( size >= u2size )
 				{
@@ -663,7 +663,7 @@ namespace MTR
 			~T10() {}
 			// ------------------------------------------
 			/*! размер в словах */
-			static unsigned int wsize()
+			static size_t wsize()
 			{
 				return u2size;
 			}
@@ -698,7 +698,7 @@ namespace MTR
 			~T16() {}
 			// ------------------------------------------
 			/*! размер в словах */
-			static unsigned int wsize()
+			static size_t wsize()
 			{
 				return 1;
 			}
@@ -746,7 +746,7 @@ namespace MTR
 			~T17() {}
 			// ------------------------------------------
 			/*! размер в словах */
-			static unsigned int wsize()
+			static size_t wsize()
 			{
 				return 1;
 			}
@@ -797,7 +797,7 @@ namespace MTR
 				raw.val = f;
 			}
 
-			F1( const ModbusRTU::ModbusData* data, int size )
+			F1( const ModbusRTU::ModbusData* data, size_t size )
 			{
 				if( size >= u2size )
 				{
@@ -810,7 +810,7 @@ namespace MTR
 			~F1() {}
 			// ------------------------------------------
 			/*! размер в словах */
-			static unsigned int wsize()
+			static size_t wsize()
 			{
 				return u2size;
 			}
@@ -855,7 +855,7 @@ namespace MTR
 			~T_Str16() {}
 			// ------------------------------------------
 			/*! размер в словах */
-			static unsigned int wsize()
+			static size_t wsize()
 			{
 				return 8;
 			}
@@ -892,7 +892,7 @@ namespace MTR
 			~T_Str8() {}
 			// ------------------------------------------
 			/*! размер в словах */
-			static unsigned int wsize()
+			static size_t wsize()
 			{
 				return 4;
 			}

extensions/include/UObject_SK.h

@@ -3,12 +3,12 @@
 /*
  DO NOT EDIT THIS FILE. IT IS AUTOGENERATED FILE.
  ALL YOUR CHANGES WILL BE LOST.
- 
+
  НЕ РЕДАКТИРУЙТЕ ЭТОТ ФАЙЛ. ЭТОТ ФАЙЛ СОЗДАН АВТОМАТИЧЕСКИ.
  ВСЕ ВАШИ ИЗМЕНЕНИЯ БУДУТ ПОТЕРЯНЫ.
-*/ 
+*/
 // --------------------------------------------------------------------------
-// generate timestamp: 2016-07-26+03:00
+// generate timestamp: 2016-08-01+03:00
 // -----------------------------------------------------------------------------
 #ifndef UObject_SK_H_
 #define UObject_SK_H_
@@ -29,11 +29,11 @@ class UObject_SK:
 	public UniSetObject
 {
 	public:
-		UObject_SK( UniSetTypes::ObjectId id, xmlNode* node=UniSetTypes::uniset_conf()->getNode("UObject"), const std::string& argprefix="" );
+		UObject_SK( UniSetTypes::ObjectId id, xmlNode* node = UniSetTypes::uniset_conf()->getNode("UObject"), const std::string& argprefix = "" );
 		UObject_SK();
 		virtual ~UObject_SK();
 
-		
+
 		long getValue( UniSetTypes::ObjectId sid );
 		void setValue( UniSetTypes::ObjectId sid, long value );
 		void askSensor( UniSetTypes::ObjectId sid, UniversalIO::UIOCommand, UniSetTypes::ObjectId node = UniSetTypes::uniset_conf()->getLocalNode() );
@@ -43,116 +43,128 @@ class UObject_SK:
 
 		virtual bool setMsg( UniSetTypes::ObjectId code, bool state = true );
 
-		inline std::shared_ptr<DebugStream> log(){ return mylog; }
-		inline std::shared_ptr<LogAgregator> logAgregator(){ return loga; }
+		inline std::shared_ptr<DebugStream> log()
+		{
+			return mylog;
+		}
+		inline std::shared_ptr<LogAgregator> logAgregator()
+		{
+			return loga;
+		}
 
 		void init_dlog( std::shared_ptr<DebugStream> d );
 
-        // "синтаксический сахар"..для логов
-        #ifndef myinfo 
-        	#define myinfo if( log()->debugging(Debug::INFO) ) log()->info() 
-        #endif
-        #ifndef mywarn
-	        #define mywarn if( log()->debugging(Debug::WARN) ) log()->warn()
-        #endif
-        #ifndef mycrit
-    	    #define mycrit if( log()->debugging(Debug::CRIT) ) log()->crit()
-        #endif
-        #ifndef mylog1
-        	#define mylog1 if( log()->debugging(Debug::LEVEL1) ) log()->level1()
-        #endif
-        #ifndef mylog2
-	        #define mylog2 if( log()->debugging(Debug::LEVEL2) ) log()->level2()
-        #endif
-        #ifndef mylog3
-    	    #define mylog3 if( log()->debugging(Debug::LEVEL3) ) log()->level3()
-        #endif
-        #ifndef mylog4
-        	#define mylog4 if( log()->debugging(Debug::LEVEL4) ) log()->level4()
-        #endif
-        #ifndef mylog5
-	        #define mylog5 if( log()->debugging(Debug::LEVEL5) ) log()->level5()
-        #endif
-        #ifndef mylog6
-    	    #define mylog6 if( log()->debugging(Debug::LEVEL6) ) log()->level6()
-        #endif
-        #ifndef mylog7
-        	#define mylog7 if( log()->debugging(Debug::LEVEL7) ) log()->level7()
-        #endif
-        #ifndef mylog8
-	        #define mylog8 if( log()->debugging(Debug::LEVEL8) ) log()->level8()
-        #endif
-        #ifndef mylog9
-    	    #define mylog9 if( log()->debugging(Debug::LEVEL9) ) log()->level9()
-        #endif
-        #ifndef mylogany
-        	#define mylogany log()->any()
-        #endif
-        #ifndef vmonit
-            #define vmonit( var ) vmon.add( #var, var )
-        #endif
-        
-        // Вспомогательные функции для удобства логирования
-        // ------------------------------------------------------------
-        /*! вывод в строку значение всех входов и выходов в формате
-           ObjectName: 
-              in_xxx  = val
-              in_xxx2 = val
-              out_zzz = val
-              ...
-        */
-        std::string dumpIO();
-        
-        /*! Вывод в строку названия входа/выхода в формате: in_xxx(SensorName) 
-           \param id           - идентификатор датчика
-           \param showLinkName - TRUE - выводить SensorName, FALSE - не выводить
-        */
-        std::string str( UniSetTypes::ObjectId id, bool showLinkName=true );
-        
-        /*! Вывод значения входа/выхода в формате: in_xxx(SensorName)=val 
-           \param id           - идентификатор датчика
-           \param showLinkName - TRUE - выводить SensorName, FALSE - не выводить
-        */
-        std::string strval( UniSetTypes::ObjectId id, bool showLinkName=true );        
-        
-        /*! Вывод состояния внутренних переменных */
-        inline std::string dumpVars(){ return std::move(vmon.pretty_str()); }
-        // ------------------------------------------------------------
-        std::string help();
-        
+		// "синтаксический сахар"..для логов
+#ifndef myinfo
+#define myinfo if( log()->debugging(Debug::INFO) ) log()->info()
+#endif
+#ifndef mywarn
+#define mywarn if( log()->debugging(Debug::WARN) ) log()->warn()
+#endif
+#ifndef mycrit
+#define mycrit if( log()->debugging(Debug::CRIT) ) log()->crit()
+#endif
+#ifndef mylog1
+#define mylog1 if( log()->debugging(Debug::LEVEL1) ) log()->level1()
+#endif
+#ifndef mylog2
+#define mylog2 if( log()->debugging(Debug::LEVEL2) ) log()->level2()
+#endif
+#ifndef mylog3
+#define mylog3 if( log()->debugging(Debug::LEVEL3) ) log()->level3()
+#endif
+#ifndef mylog4
+#define mylog4 if( log()->debugging(Debug::LEVEL4) ) log()->level4()
+#endif
+#ifndef mylog5
+#define mylog5 if( log()->debugging(Debug::LEVEL5) ) log()->level5()
+#endif
+#ifndef mylog6
+#define mylog6 if( log()->debugging(Debug::LEVEL6) ) log()->level6()
+#endif
+#ifndef mylog7
+#define mylog7 if( log()->debugging(Debug::LEVEL7) ) log()->level7()
+#endif
+#ifndef mylog8
+#define mylog8 if( log()->debugging(Debug::LEVEL8) ) log()->level8()
+#endif
+#ifndef mylog9
+#define mylog9 if( log()->debugging(Debug::LEVEL9) ) log()->level9()
+#endif
+#ifndef mylogany
+#define mylogany log()->any()
+#endif
+#ifndef vmonit
+#define vmonit( var ) vmon.add( #var, var )
+#endif
+
+		// Вспомогательные функции для удобства логирования
+		// ------------------------------------------------------------
+		/*! вывод в строку значение всех входов и выходов в формате
+		   ObjectName:
+		      in_xxx  = val
+		      in_xxx2 = val
+		      out_zzz = val
+		      ...
+		*/
+		std::string dumpIO();
+
+		/*! Вывод в строку названия входа/выхода в формате: in_xxx(SensorName)
+		   \param id           - идентификатор датчика
+		   \param showLinkName - TRUE - выводить SensorName, FALSE - не выводить
+		*/
+		std::string str( UniSetTypes::ObjectId id, bool showLinkName = true ) const;
+
+		/*! Вывод значения входа/выхода в формате: in_xxx(SensorName)=val
+		   \param id           - идентификатор датчика
+		   \param showLinkName - TRUE - выводить SensorName, FALSE - не выводить
+		*/
+		std::string strval( UniSetTypes::ObjectId id, bool showLinkName = true ) const;
+
+		/*! Вывод состояния внутренних переменных */
+		inline std::string dumpVars()
+		{
+			return std::move(vmon.pretty_str());
+		}
+		// ------------------------------------------------------------
+		std::string help();
+
 
 
 		// Используемые идентификаторы
-		
+
 
 		// Используемые идентификаторы сообщений
-		
+
 
 		// Текущее значение
-		
+
 
 		// --- public variables ---
-		
-		
+
+
 		// --- end of public variables ---
 
 	protected:
 		// --- protected variables ---
-		
-		
+
+
 		// ---- end of protected variables ----
 
-		
+
 		virtual void callback() override;
 		virtual void processingMessage( const UniSetTypes::VoidMessage* msg ) override;
-		virtual void sysCommand( const UniSetTypes::SystemMessage* sm ){};
-		virtual void askSensors( UniversalIO::UIOCommand cmd ){}
-		virtual void sensorInfo( const UniSetTypes::SensorMessage* sm ) override{}
-		virtual void timerInfo( const UniSetTypes::TimerMessage* tm ) override{}
+		virtual void sysCommand( const UniSetTypes::SystemMessage* sm ) {};
+		virtual void askSensors( UniversalIO::UIOCommand cmd ) {}
+		virtual void sensorInfo( const UniSetTypes::SensorMessage* sm ) override {}
+		virtual void timerInfo( const UniSetTypes::TimerMessage* tm ) override {}
 		virtual void sigterm( int signo ) override;
 		virtual bool activateObject() override;
-		virtual std::string getMonitInfo(){ return ""; } /*!< пользовательская информация выводимая в getInfo() */
-		
+		virtual std::string getMonitInfo()
+		{
+			return "";    /*!< пользовательская информация выводимая в getInfo() */
+		}
+
 		virtual void testMode( bool state );
 		void updatePreviousValues();
 		void checkSensors();
@@ -172,7 +184,7 @@ class UObject_SK:
 		int resetMsgTime;
 
 		// Выполнение очередного шага программы
-		virtual void step(){}
+		virtual void step() {}
 
 		int sleep_msec; /*!< пауза между итерациями */
 		bool active;
@@ -184,22 +196,28 @@ class UObject_SK:
 		PassiveTimer ptHeartBeat;				/*! < период "сердцебиения" */
 		UniSetTypes::ObjectId idHeartBeat;		/*! < идентификатор датчика (AI) "сердцебиения" */
 		int maxHeartBeat;						/*! < сохраняемое значение */
-		
+
 		xmlNode* confnode;
 		/*! получить числовое свойство из конф. файла по привязанной confnode */
-		int getIntProp(const std::string& name) { return UniSetTypes::uniset_conf()->getIntProp(confnode, name); }
+		int getIntProp(const std::string& name)
+		{
+			return UniSetTypes::uniset_conf()->getIntProp(confnode, name);
+		}
 		/*! получить текстовое свойство из конф. файла по привязанной confnode */
-		inline const std::string getProp(const std::string& name) { return UniSetTypes::uniset_conf()->getProp(confnode, name); }
+		inline const std::string getProp(const std::string& name)
+		{
+			return UniSetTypes::uniset_conf()->getProp(confnode, name);
+		}
 
 		timeout_t smReadyTimeout; 	/*!< время ожидания готовности SM */
 		std::atomic_bool activated;
 		timeout_t activateTimeout;	/*!< время ожидания готовности UniSetObject к работе */
 		PassiveTimer ptStartUpTimeout;	/*!< время на блокировку обработки WatchDog, если недавно был StartUp */
 		int askPause; /*!< пауза между неудачными попытками заказать датчики */
-		
+
 		IOController_i::SensorInfo si;
 		bool forceOut; /*!< флаг принудительного обноления "выходов" */
-		
+
 		std::shared_ptr<LogAgregator> loga;
 		std::shared_ptr<DebugStream> mylog;
 		std::shared_ptr<LogServer> logserv;
@@ -208,21 +226,21 @@ class UObject_SK:
 
 		// snap
 		bool no_snap = {false};
-		
+
 		VMonitor vmon;
 
-		
+
 
 	private:
-		
+
 		// --- private variables ---
 		// --- end of private variables ---
 
 		// предыдущее значение (для работы UpdateValue())
-		
+
 
 		// Используемые идентификаторы сообщений
-		
+
 
 		bool end_private; // вспомогательное поле (для внутреннего использования при генерировании кода)
 };

extensions/include/VTypes.h

@@ -54,7 +54,7 @@ namespace VTypes
 		public:
 
 			// ------------------------------------------
-			static const int f2Size = 2;
+			static const size_t f2Size = 2;
 			/*! тип хранения в памяти */
 			typedef union
 			{
@@ -72,16 +72,16 @@ namespace VTypes
 			{
 				raw.val = f;
 			}
-			F2( const ModbusRTU::ModbusData* data, int size )
+			F2( const ModbusRTU::ModbusData* data, size_t size )
 			{
-				for( int i = 0; i < wsize() && i < size; i++ )
+				for( size_t i = 0; i < wsize() && i < size; i++ )
 					raw.v[i] = data[i];
 			}
 
 			~F2() {}
 			// ------------------------------------------
 			/*! размер в словах */
-			static int wsize()
+			static size_t wsize()
 			{
 				return f2Size;
 			}
@@ -121,7 +121,7 @@ namespace VTypes
 				raw_backorder = raw;
 				std::swap(raw_backorder.v[0], raw_backorder.v[1]);
 			}
-			F2r( const ModbusRTU::ModbusData* data, int size ): F2(data, size)
+			F2r( const ModbusRTU::ModbusData* data, size_t size ): F2(data, size)
 			{
 				// принимаем в обратном порядке.. поэтому переворачиваем raw
 				raw_backorder = raw;
@@ -137,7 +137,7 @@ namespace VTypes
 	{
 		public:
 			// ------------------------------------------
-			static const int f4Size = 4;
+			static const size_t f4Size = 4;
 			/*! тип хранения в памяти */
 			typedef union
 			{
@@ -155,16 +155,16 @@ namespace VTypes
 			{
 				raw.val = f;
 			}
-			F4( const ModbusRTU::ModbusData* data, int size )
+			F4( const ModbusRTU::ModbusData* data, size_t size )
 			{
-				for( int i = 0; i < wsize() && i < size; i++ )
+				for( size_t i = 0; i < wsize() && i < size; i++ )
 					raw.v[i] = data[i];
 			}
 
 			~F4() {}
 			// ------------------------------------------
 			/*! размер в словах */
-			static int wsize()
+			static size_t wsize()
 			{
 				return f4Size;
 			}
@@ -190,7 +190,7 @@ namespace VTypes
 	{
 		public:
 
-			static const int bsize = 2;
+			static const size_t bsize = 2;
 
 			// ------------------------------------------
 			/*! тип хранения в памяти */
@@ -224,7 +224,7 @@ namespace VTypes
 			~Byte() {}
 			// ------------------------------------------
 			/*! размер в словах */
-			static int wsize()
+			static size_t wsize()
 			{
 				return 1;
 			}
@@ -272,7 +272,7 @@ namespace VTypes
 			~Unsigned() {}
 			// ------------------------------------------
 			/*! размер в словах */
-			static int wsize()
+			static size_t wsize()
 			{
 				return 1;
 			}
@@ -311,7 +311,7 @@ namespace VTypes
 			~Signed() {}
 			// ------------------------------------------
 			/*! размер в словах */
-			static int wsize()
+			static size_t wsize()
 			{
 				return 1;
 			}
@@ -334,7 +334,7 @@ namespace VTypes
 		public:
 
 			// ------------------------------------------
-			static const int i2Size = 2;
+			static const size_t i2Size = 2;
 			/*! тип хранения в памяти */
 			typedef union
 			{
@@ -352,16 +352,16 @@ namespace VTypes
 			{
 				raw.val = v;
 			}
-			I2( const ModbusRTU::ModbusData* data, int size )
+			I2( const ModbusRTU::ModbusData* data, size_t size )
 			{
-				for( int i = 0; i < wsize() && i < size; i++ )
+				for( size_t i = 0; i < wsize() && i < size; i++ )
 					raw.v[i] = data[i];
 			}
 
 			~I2() {}
 			// ------------------------------------------
 			/*! размер в словах */
-			static int wsize()
+			static size_t wsize()
 			{
 				return i2Size;
 			}
@@ -390,7 +390,7 @@ namespace VTypes
 				raw_backorder = raw;
 				std::swap(raw_backorder.v[0], raw_backorder.v[1]);
 			}
-			I2r( const ModbusRTU::ModbusData* data, int size ): I2(data, size)
+			I2r( const ModbusRTU::ModbusData* data, size_t size ): I2(data, size)
 			{
 				// принимаем в обратном порядке.. поэтому переворачиваем raw
 				raw_backorder = raw;
@@ -407,7 +407,7 @@ namespace VTypes
 		public:
 
 			// ------------------------------------------
-			static const int u2Size = 2;
+			static const size_t u2Size = 2;
 			/*! тип хранения в памяти */
 			typedef union
 			{
@@ -425,16 +425,16 @@ namespace VTypes
 			{
 				raw.val = v;
 			}
-			U2( const ModbusRTU::ModbusData* data, int size )
+			U2( const ModbusRTU::ModbusData* data, size_t size )
 			{
-				for( int i = 0; i < wsize() && i < size; i++ )
+				for( size_t i = 0; i < wsize() && i < size; i++ )
 					raw.v[i] = data[i];
 			}
 
 			~U2() {}
 			// ------------------------------------------
 			/*! размер в словах */
-			static int wsize()
+			static size_t wsize()
 			{
 				return u2Size;
 			}
@@ -463,7 +463,7 @@ namespace VTypes
 				raw_backorder = raw;
 				std::swap(raw_backorder.v[0], raw_backorder.v[1]);
 			}
-			U2r( const ModbusRTU::ModbusData* data, int size ): U2(data, size)
+			U2r( const ModbusRTU::ModbusData* data, size_t size ): U2(data, size)
 			{
 				// принимаем в обратном порядке.. поэтому переворачиваем raw
 				raw_backorder = raw;

extensions/lib/MTR.cc

@@ -128,7 +128,7 @@ namespace MTR
 		return "Unknown";
 	}
 	// -------------------------------------------------------------------------
-	int wsize(  MTRType t )
+	size_t wsize(  MTRType t )
 	{
 		if( t == mtT1 )
 			return T1::wsize();

extensions/lib/UObject_SK.cc

@@ -6,12 +6,12 @@
 /*
  DO NOT EDIT THIS FILE. IT IS AUTOGENERATED FILE.
  ALL YOUR CHANGES WILL BE LOST.
- 
+
  НЕ РЕДАКТИРУЙТЕ ЭТОТ ФАЙЛ. ЭТОТ ФАЙЛ СОЗДАН АВТОМАТИЧЕСКИ.
  ВСЕ ВАШИ ИЗМЕНЕНИЯ БУДУТ ПОТЕРЯНЫ.
-*/ 
+*/
 // --------------------------------------------------------------------------
-// generate timestamp: 2016-07-26+03:00
+// generate timestamp: 2016-08-01+03:00
 // -----------------------------------------------------------------------------
 #include <memory>
 #include <iomanip>
@@ -32,26 +32,26 @@ using namespace UniSetTypes;
 
 // -----------------------------------------------------------------------------
 UObject_SK::UObject_SK():
-// Инициализация идентификаторов (имена берутся из конф. файла)
+	// Инициализация идентификаторов (имена берутся из конф. файла)
 
-// Используемые идентификаторы сообщений (имена берутся из конф. файла)
+	// Используемые идентификаторы сообщений (имена берутся из конф. файла)
 
-// variables
+	// variables
 
-active(false),
+	active(false),
 
-idHeartBeat(DefaultObjectId),
-maxHeartBeat(10),
-confnode(0),
-smReadyTimeout(0),
-activated(false),
-askPause(2000),
-forceOut(false),
+	idHeartBeat(DefaultObjectId),
+	maxHeartBeat(10),
+	confnode(0),
+	smReadyTimeout(0),
+	activated(false),
+	askPause(2000),
+	forceOut(false),
 
-end_private(false)
+	end_private(false)
 {
 	mycrit << "UObject: init failed!!!!!!!!!!!!!!!" << endl;
-	throw Exception( string(myname+": init failed!!!") );
+	throw Exception( string(myname + ": init failed!!!") );
 }
 // -----------------------------------------------------------------------------
 // ( val, confval, default val )
@@ -59,41 +59,42 @@ static const std::string init3_str( const std::string& s1, const std::string& s2
 {
 	if( !s1.empty() )
 		return s1;
+
 	if( !s2.empty() )
 		return s2;
-	
+
 	return s3;
 }
 // -----------------------------------------------------------------------------
 UObject_SK::UObject_SK( ObjectId id, xmlNode* cnode, const std::string& _argprefix ):
-UniSetObject(id),
-// Инициализация идентификаторов (имена берутся из конф. файла)
+	UniSetObject(id),
+	// Инициализация идентификаторов (имена берутся из конф. файла)
 
-// Используемые идентификаторы сообщений (имена берутся из конф. файла)
+	// Используемые идентификаторы сообщений (имена берутся из конф. файла)
 
-// variables
+	// variables
 
-sleep_msec(150),
-active(true),
-argprefix( (_argprefix.empty() ? myname+"-" : _argprefix) ),
+	sleep_msec(150),
+	active(true),
+	argprefix( (_argprefix.empty() ? myname + "-" : _argprefix) ),
 
-idHeartBeat(DefaultObjectId),
-maxHeartBeat(10),
-confnode(cnode),
-smReadyTimeout(0),
-activated(false),
-askPause(uniset_conf()->getPIntProp(cnode,"askPause",2000)),
-forceOut(false),
+	idHeartBeat(DefaultObjectId),
+	maxHeartBeat(10),
+	confnode(cnode),
+	smReadyTimeout(0),
+	activated(false),
+	askPause(uniset_conf()->getPIntProp(cnode, "askPause", 2000)),
+	forceOut(false),
 
-end_private(false)
+	end_private(false)
 {
 	auto conf = uniset_conf();
 
-	
-	if( UniSetTypes::findArgParam("--print-id-list",uniset_conf()->getArgc(),uniset_conf()->getArgv()) != -1 )
+
+	if( UniSetTypes::findArgParam("--print-id-list", uniset_conf()->getArgc(), uniset_conf()->getArgv()) != -1 )
 	{
 
-//		abort();
+		//		abort();
 	}
 
 
@@ -104,15 +105,15 @@ end_private(false)
 		throw SystemError( err.str() );
 	}
 
-    mylog = make_shared<DebugStream>();
+	mylog = make_shared<DebugStream>();
 	mylog->setLogName(myname);
 	{
 		ostringstream s;
 		s << argprefix << "log";
-		conf->initLogStream(mylog,s.str());
+		conf->initLogStream(mylog, s.str());
 	}
 
-	loga = make_shared<LogAgregator>(myname+"-loga");
+	loga = make_shared<LogAgregator>(myname + "-loga");
 	loga->add(mylog);
 	loga->add(ulog());
 
@@ -129,13 +130,15 @@ end_private(false)
 		logserv_host = conf->getArg2Param("--" + argprefix + "logserver-host", it.getProp("logserverHost"), "localhost");
 		logserv_port = conf->getArgPInt("--" + argprefix + "logserver-port", it.getProp("logserverPort"), getId());
 	}
-	
-	forceOut = conf->getArgPInt("--" + argprefix + "force-out",it.getProp("forceOut"),false);
 
-	string heart = conf->getArgParam("--" + argprefix + "heartbeat-id",it.getProp("heartbeat_id"));
+	forceOut = conf->getArgPInt("--" + argprefix + "force-out", it.getProp("forceOut"), false);
+
+	string heart = conf->getArgParam("--" + argprefix + "heartbeat-id", it.getProp("heartbeat_id"));
+
 	if( !heart.empty() )
 	{
 		idHeartBeat = conf->getSensorID(heart);
+
 		if( idHeartBeat == DefaultObjectId )
 		{
 			ostringstream err;
@@ -143,31 +146,34 @@ end_private(false)
 			throw SystemError(err.str());
 		}
 
-		int heartbeatTime = conf->getArgPInt("--" + argprefix + "heartbeat-time",it.getProp("heartbeatTime"),conf->getHeartBeatTime());
-		if( heartbeatTime>0 )
+		int heartbeatTime = conf->getArgPInt("--" + argprefix + "heartbeat-time", it.getProp("heartbeatTime"), conf->getHeartBeatTime());
+
+		if( heartbeatTime > 0 )
 			ptHeartBeat.setTiming(heartbeatTime);
 		else
 			ptHeartBeat.setTiming(UniSetTimer::WaitUpTime);
 
-		maxHeartBeat = conf->getArgPInt("--" + argprefix + "heartbeat-max",it.getProp("heartbeat_max"), 10);
+		maxHeartBeat = conf->getArgPInt("--" + argprefix + "heartbeat-max", it.getProp("heartbeat_max"), 10);
 	}
 
 	// Инициализация значений
-	
-	
+
+
 	si.id = UniSetTypes::DefaultObjectId;
 	si.node = conf->getLocalNode();
-	
-	sleep_msec = conf->getArgPInt("--" + argprefix + "sleep-msec","150", 150);
+
+	sleep_msec = conf->getArgPInt("--" + argprefix + "sleep-msec", "150", 150);
 
 	string s_resetTime("");
+
 	if( s_resetTime.empty() )
 		s_resetTime = "500";
 
-	resetMsgTime = uni_atoi(init3_str(conf->getArgParam("--" + argprefix + "resetMsgTime"),conf->getProp(cnode,"resetMsgTime"),s_resetTime));
+	resetMsgTime = uni_atoi(init3_str(conf->getArgParam("--" + argprefix + "resetMsgTime"), conf->getProp(cnode, "resetMsgTime"), s_resetTime));
 	ptResetMsg.setTiming(resetMsgTime);
 
-	int sm_tout = conf->getArgInt("--" + argprefix + "sm-ready-timeout","");
+	int sm_tout = conf->getArgInt("--" + argprefix + "sm-ready-timeout", "");
+
 	if( sm_tout == 0 )
 		smReadyTimeout = 60000;
 	else if( sm_tout < 0 )
@@ -175,8 +181,8 @@ end_private(false)
 	else
 		smReadyTimeout = sm_tout;
 
-	smTestID = conf->getSensorID(init3_str(conf->getArgParam("--" + argprefix + "sm-test-id"),conf->getProp(cnode,"smTestID"),""));
-	
+	smTestID = conf->getSensorID(init3_str(conf->getArgParam("--" + argprefix + "sm-test-id"), conf->getProp(cnode, "smTestID"), ""));
+
 
 	if( smTestID == DefaultObjectId )
 		smTestID = getSMTestID();
@@ -187,7 +193,7 @@ end_private(false)
 	ptStartUpTimeout.setTiming(msec);
 
 	// ===================== <variables> =====================
-	
+
 	// ===================== end of <variables> =====================
 
 	vmonit(sleep_msec);
@@ -209,17 +215,17 @@ UObject_SK::~UObject_SK()
 void UObject_SK::updateValues()
 {
 	// Опрашиваем все входы...
-	
+
 }
 // -----------------------------------------------------------------------------
 void UObject_SK::updatePreviousValues()
 {
-	
+
 }
 // -----------------------------------------------------------------------------
 void UObject_SK::checkSensors()
 {
-	
+
 }
 // -----------------------------------------------------------------------------
 bool UObject_SK::setMsg( UniSetTypes::ObjectId _code, bool _state )
@@ -227,28 +233,28 @@ bool UObject_SK::setMsg( UniSetTypes::ObjectId _code, bool _state )
 	if( _code == UniSetTypes::DefaultObjectId )
 	{
 		mylog8 << myname << "(setMsg): попытка послать сообщение с DefaultObjectId" << endl;
-		return false;	
+		return false;
+	}
+
+	mylog8 << myname << "(setMsg): " << ( _state ? "SEND " : "RESET " ) << endl;
+
+	// взводим автоматический сброс
+	if( _state )
+	{
+		ptResetMsg.reset();
+		trResetMsg.hi(false);
 	}
 
-    mylog8 << myname << "(setMsg): " << ( _state ? "SEND " : "RESET " ) << endl;
 
-    // взводим автоматический сброс
-    if( _state )
-    {
-        ptResetMsg.reset();
-        trResetMsg.hi(false);
-    }
 
-	
-	
-    mylog8 << myname << "(setMsg): not found MessgeOID?!!" << endl;
+	mylog8 << myname << "(setMsg): not found MessgeOID?!!" << endl;
 	return false;
 }
 // -----------------------------------------------------------------------------
 void UObject_SK::resetMsg()
 {
-    mylog8 << myname << "(resetMsg): reset messages.." << endl;
-// reset messages
+	mylog8 << myname << "(resetMsg): reset messages.." << endl;
+	// reset messages
 
 }
 // -----------------------------------------------------------------------------
@@ -257,7 +263,7 @@ UniSetTypes::ObjectId UObject_SK::getSMTestID()
 	if( smTestID != DefaultObjectId )
 		return smTestID;
 
-	
+
 
 	return DefaultObjectId;
 }
@@ -268,7 +274,7 @@ void UObject_SK::testMode( bool _state )
 		return;
 
 	// отключаем все выходы
-	
+
 }
 // -----------------------------------------------------------------------------
 std::string  UObject_SK::dumpIO()
@@ -278,44 +284,48 @@ std::string  UObject_SK::dumpIO()
 
 	std::list<std::string> v_in;
 	ostringstream s1;
-	
-	
+
+
 	std::list<std::string> v_out;
-	
+
 
 	s << endl;
 
 	int n = 0;
-	for( const auto& e: v_in )
+
+	for( const auto& e : v_in )
 	{
 		s << e;
-		if( (n++)%2 )
+
+		if( (n++) % 2 )
 			s << std::endl;
 	}
-	
+
 	s << endl;
 	n = 0;
-	for( const auto& e: v_out )
+
+	for( const auto& e : v_out )
 	{
 		s << e;
-		if( (n++)%2 )
+
+		if( (n++) % 2 )
 			s << std::endl;
 	}
-	
+
 	return std::move(s.str());
 }
 // ----------------------------------------------------------------------------
-std::string  UObject_SK::str( UniSetTypes::ObjectId id, bool showLinkName )
+std::string  UObject_SK::str( UniSetTypes::ObjectId id, bool showLinkName ) const
 {
 	ostringstream s;
-		
+
 	return "";
 }
 // ----------------------------------------------------------------------------
-std::string  UObject_SK::strval( UniSetTypes::ObjectId id, bool showLinkName )
+std::string  UObject_SK::strval( UniSetTypes::ObjectId id, bool showLinkName ) const
 {
 	ostringstream s;
-		
+
 	return "";
 }
 // ----------------------------------------------------------------------------
@@ -336,19 +346,19 @@ void UObject_SK::processingMessage( const UniSetTypes::VoidMessage* _msg )
 		{
 			case Message::SensorInfo:
 				preSensorInfo( reinterpret_cast<const SensorMessage*>(_msg) );
-			break;
+				break;
 
 			case Message::Timer:
 				preTimerInfo( reinterpret_cast<const TimerMessage*>(_msg) );
-			break;
+				break;
 
 			case Message::SysCommand:
 				preSysCommand( reinterpret_cast<const SystemMessage*>(_msg) );
-			break;
-                                                                                        
+				break;
+
 			default:
 				break;
-		}	
+		}
 	}
 	catch( const Exception& ex )
 	{
@@ -362,11 +372,13 @@ void UObject_SK::preSysCommand( const SystemMessage* _sm )
 	{
 		case SystemMessage::WatchDog:
 			myinfo << myname << "(preSysCommand): WatchDog" << endl;
+
 			if( !active || !ptStartUpTimeout.checkTime() )
 			{
 				mywarn << myname << "(preSysCommand): игнорируем WatchDog, потому-что только-что стартанули" << endl;
 				break;
 			}
+
 		case SystemMessage::StartUp:
 		{
 			if( !logserv_host.empty() && logserv_port != 0 && !logserv->isRunning() )
@@ -387,21 +399,22 @@ void UObject_SK::preSysCommand( const SystemMessage* _sm )
 			active = true;
 			break;
 		}
-		
+
 		case SystemMessage::FoldUp:
 		case SystemMessage::Finish:
 			preAskSensors(UniversalIO::UIODontNotify);
 			askSensors(UniversalIO::UIODontNotify);
 			break;
-		
+
 		case SystemMessage::LogRotate:
 		{
 			// переоткрываем логи
 			mylogany << myname << "(preSysCommand): logRotate" << endl;
 			string fname( log()->getLogFile() );
+
 			if( !fname.empty() )
 			{
-				mylog->logFile(fname.c_str(),true);
+				mylog->logFile(fname.c_str(), true);
 				mylogany << myname << "(preSysCommand): ***************** mylog LOG ROTATE *****************" << endl;
 			}
 		}
@@ -410,7 +423,7 @@ void UObject_SK::preSysCommand( const SystemMessage* _sm )
 		default:
 			break;
 	}
-	
+
 	sysCommand(_sm);
 }
 // -----------------------------------------------------------------------------
@@ -418,30 +431,32 @@ void UObject_SK::preSysCommand( const SystemMessage* _sm )
 UniSetTypes::SimpleInfo* UObject_SK::getInfo( CORBA::Long userparam )
 {
 	UniSetTypes::SimpleInfo_var i = UniSetObject::getInfo(userparam);
-	
+
 	ostringstream inf;
-	
+
 	inf << i->info << endl;
 	inf << "LogServer: " << logserv_host << ":" << logserv_port << endl;
 	inf << dumpIO() << endl;
 	inf << endl;
 	auto timers = getTimersList();
 	inf << "Timers[" << timers.size() << "]:" << endl;
-	for( const auto& t: timers )
+
+	for( const auto& t : timers )
 	{
 		inf << "  " << setw(15) << getTimerName(t.id) << "[" << t.id  << "]: msec="
 			<< setw(6) << t.tmr.getInterval()
 			<< "    timeleft="  << setw(6) << t.curTimeMS
-			<< "    tick="  << setw(3) << ( t.curTick>=0 ? t.curTick : -1 )
+			<< "    tick="  << setw(3) << ( t.curTick >= 0 ? t.curTick : -1 )
 			<< endl;
 	}
+
 	inf << endl;
 	inf << vmon.pretty_str() << endl;
 	inf << endl;
 	inf << getMonitInfo() << endl;
-	
+
 	i->info =  inf.str().c_str();
-	
+
 	return i._retn();
 }
 // -----------------------------------------------------------------------------
@@ -456,7 +471,7 @@ void UObject_SK::sigterm( int signo )
 // -----------------------------------------------------------------------------
 bool UObject_SK::activateObject()
 {
-	// блокирование обработки Startup 
+	// блокирование обработки Startup
 	// пока не пройдёт инициализация датчиков
 	// см. preSysCommand()
 	{
@@ -482,47 +497,47 @@ void UObject_SK::waitSM( int wait_msec, ObjectId _testID )
 
 	if( _testID == DefaultObjectId )
 		return;
-		
+
 	myinfo << myname << "(waitSM): waiting SM ready "
-			<< wait_msec << " msec"
-			<< " testID=" << _testID << endl;
-		
+		   << wait_msec << " msec"
+		   << " testID=" << _testID << endl;
+
 	// waitReady можно использовать т.к. датчик это по сути IONotifyController
-	if( !ui->waitReady(_testID,wait_msec) )
+	if( !ui->waitReady(_testID, wait_msec) )
 	{
 		ostringstream err;
-		err << myname 
-			<< "(waitSM): Не дождались готовности(exist) SharedMemory к работе в течение " 
+		err << myname
+			<< "(waitSM): Не дождались готовности(exist) SharedMemory к работе в течение "
 			<< wait_msec << " мсек";
 
-        mycrit << err.str() << endl;
-//		terminate();
-//		abort();
+		mycrit << err.str() << endl;
+		//		terminate();
+		//		abort();
 		raise(SIGTERM);
 		terminate();
-//		throw SystemError(err.str());
+		//		throw SystemError(err.str());
 	}
 
-	if( !ui->waitWorking(_testID,wait_msec) )
+	if( !ui->waitWorking(_testID, wait_msec) )
 	{
 		ostringstream err;
 		err << myname
 			<< "(waitSM): Не дождались готовности(work) SharedMemory к работе в течение "
 			<< wait_msec << " мсек";
-	
+
 		mycrit << err.str() << endl;
-//		terminate();
-//		abort();
+		//		terminate();
+		//		abort();
 		raise(SIGTERM);
-//		throw SystemError(err.str());
+		//		throw SystemError(err.str());
 	}
 }
 // ----------------------------------------------------------------------------
 std::string UObject_SK::help()
 {
 	ostringstream s;
-	
-	
+
+
 	return std::move(s.str());
 }
 // ----------------------------------------------------------------------------
@@ -532,39 +547,42 @@ void UObject_SK::callback()
 {
 	if( !active )
 		return;
+
 	try
 	{
 
 		// проверка таймеров
 		checkTimers(this);
 
-		if( resetMsgTime>0 && trResetMsg.hi(ptResetMsg.checkTime()) )
+		if( resetMsgTime > 0 && trResetMsg.hi(ptResetMsg.checkTime()) )
 		{
-//			cout << myname <<  ": ********* reset messages *********" << endl;
+			//			cout << myname <<  ": ********* reset messages *********" << endl;
 			resetMsg();
 		}
 
 		// обработка сообщений (таймеров и т.п.)
-		for( unsigned int i=0; i<20; i++ )
+		for( unsigned int i = 0; i < 20; i++ )
 		{
-            auto m = receiveMessage();
-            if( !m )
-                break;
-            processingMessage(m.get());
+			auto m = receiveMessage();
+
+			if( !m )
+				break;
+
+			processingMessage(m.get());
 
 			updateOutputs(forceOut);
-//			updatePreviousValues();
+			//			updatePreviousValues();
 		}
 
 		// Выполнение шага программы
 		step();
 
 		// "сердцебиение"
-		if( idHeartBeat!=DefaultObjectId && ptHeartBeat.checkTime() )
+		if( idHeartBeat != DefaultObjectId && ptHeartBeat.checkTime() )
 		{
 			try
 			{
-				ui->setValue(idHeartBeat,maxHeartBeat);
+				ui->setValue(idHeartBeat, maxHeartBeat);
 				ptHeartBeat.reset();
 			}
 			catch( const Exception& ex )
@@ -579,21 +597,21 @@ void UObject_SK::callback()
 	}
 	catch( const Exception& ex )
 	{
-        mycrit << myname << "(execute): " << ex << endl;
+		mycrit << myname << "(execute): " << ex << endl;
 	}
 	catch( const CORBA::SystemException& ex )
 	{
-        mycrit << myname << "(execute): СORBA::SystemException: "
-                << ex.NP_minorString() << endl;
+		mycrit << myname << "(execute): СORBA::SystemException: "
+			   << ex.NP_minorString() << endl;
+	}
+	catch( const std::exception& ex )
+	{
+		mycrit << myname << "(execute): catch " << ex.what()  <<   endl;
 	}
-    catch( const std::exception&ex )
-    {
-        mycrit << myname << "(execute): catch " << ex.what()  <<   endl;
-    }
 
 	if( !active )
 		return;
-	
+
 	msleep( sleep_msec );
 }
 // -----------------------------------------------------------------------------
@@ -601,32 +619,32 @@ void UObject_SK::setValue( UniSetTypes::ObjectId _sid, long _val )
 {
 	if( _sid == UniSetTypes::DefaultObjectId )
 		return;
-		
-	
 
-	ui->setValue(_sid,_val);
+
+
+	ui->setValue(_sid, _val);
 }
 // -----------------------------------------------------------------------------
 void UObject_SK::updateOutputs( bool _force )
 {
-	
+
 }
 // -----------------------------------------------------------------------------
 void UObject_SK::preSensorInfo( const UniSetTypes::SensorMessage* _sm )
 {
-	
-	
+
+
 	sensorInfo(_sm);
 }
 // -----------------------------------------------------------------------------
 void UObject_SK::initFromSM()
 {
-	
+
 }
 // -----------------------------------------------------------------------------
 void UObject_SK::askSensor( UniSetTypes::ObjectId _sid, UniversalIO::UIOCommand _cmd, UniSetTypes::ObjectId _node )
 {
-	ui->askRemoteSensor(_sid,_cmd,_node,getId());
+	ui->askRemoteSensor(_sid, _cmd, _node, getId());
 }
 // -----------------------------------------------------------------------------
 long UObject_SK::getValue( UniSetTypes::ObjectId _sid )
@@ -639,7 +657,7 @@ long UObject_SK::getValue( UniSetTypes::ObjectId _sid )
 	}
 	catch( const Exception& ex )
 	{
-        mycrit << myname << "(getValue): " << ex << endl;
+		mycrit << myname << "(getValue): " << ex << endl;
 		throw;
 	}
 }
@@ -648,33 +666,35 @@ long UObject_SK::getValue( UniSetTypes::ObjectId _sid )
 void UObject_SK::preAskSensors( UniversalIO::UIOCommand _cmd )
 {
 	PassiveTimer ptAct(activateTimeout);
+
 	while( !activated && !ptAct.checkTime() )
-	{	
+	{
 		cout << myname << "(preAskSensors): wait activate..." << endl;
 		msleep(300);
+
 		if( activated )
 			break;
 	}
-			
+
 	if( !activated )
 		mycrit << myname
-			<< "(preAskSensors): ************* don`t activated?! ************" << endl;
+			   << "(preAskSensors): ************* don`t activated?! ************" << endl;
 
 	for( ;; )
 	{
 		try
 		{
-		
+
 			return;
 		}
 		catch( const Exception& ex )
 		{
-            mycrit << myname << "(preAskSensors): " << ex << endl;
+			mycrit << myname << "(preAskSensors): " << ex << endl;
+		}
+		catch( const std::exception& ex )
+		{
+			mycrit << myname << "(execute): catch " << ex.what()  <<   endl;
 		}
-	    catch( const std::exception&ex )
-    	{
-		mycrit << myname << "(execute): catch " << ex.what()  <<   endl;
-	    }
 
 		msleep(askPause);
 	}

extensions/tests/MQPerfTest/mq-test.cc

@@ -23,20 +23,22 @@ int main(int argc, const char** argv)
 		act->broadcast( sm.transport_msg() );
 		act->run(true);
 
-		SensorMessage smsg(100,2);
+		SensorMessage smsg(100, 2);
 		TransportMessage tm( std::move(smsg.transport_msg()) );
 
 		size_t num = 0;
 		const size_t max = 100000;
 		std::chrono::time_point<std::chrono::system_clock> start, end;
 		start = std::chrono::system_clock::now();
-		for( num=0; num<max; num++ )
+
+		for( num = 0; num < max; num++ )
 		{
 			tp->push(tm);
+
 			if( tp->isFullQueue() )
 				break;
 
-			if( num%100 == 0 )
+			if( num % 100 == 0 )
 				msleep(50);
 		}
 

extensions/tests/SMemoryTest/TestProc.cc

@@ -51,6 +51,14 @@ void TestProc::sysCommand( const UniSetTypes::SystemMessage* sm )
 	}
 }
 // -----------------------------------------------------------------------------
+string TestProc::getMonitInfo()
+{
+	int* p = 0;
+	(*p) = 10;
+
+	return "";
+}
+// -----------------------------------------------------------------------------
 void TestProc::sensorInfo( const SensorMessage* sm )
 {
 	/*

extensions/tests/SMemoryTest/TestProc.h

@@ -25,9 +25,10 @@ class TestProc:
 		};
 
 		virtual void step();
-		virtual void sensorInfo( const UniSetTypes::SensorMessage* sm );
-		virtual void timerInfo( const UniSetTypes::TimerMessage* tm );
-		virtual void sysCommand( const UniSetTypes::SystemMessage* sm );
+		virtual void sensorInfo( const UniSetTypes::SensorMessage* sm ) override;
+		virtual void timerInfo( const UniSetTypes::TimerMessage* tm ) override;
+		virtual void sysCommand( const UniSetTypes::SystemMessage* sm ) override;
+		virtual std::string getMonitInfo() override;
 
 		void test_depend();
 		void test_undefined_state();

extensions/tests/SMemoryTest/abort-script-example.sh

 #!/bin/sh
 
-gdb --batch -n -ex "thread apply all bt" $1 $2
+exec gdb --batch -n -ex "thread apply all bt" $1 $2
 # | ssh xxxxxx
 
 # gcore $2

include/EventLoopServer.h

@@ -18,7 +18,7 @@ class EventLoopServer
 		EventLoopServer();
 		virtual ~EventLoopServer();
 
-		bool evIsActive();
+		bool evIsActive() const;
 
 	protected:
 		// действия при завершении

include/HourGlass.h

@@ -123,19 +123,19 @@ class HourGlass
 		}
 
 		// получить прошедшее время
-		inline timeout_t current()
+		inline timeout_t current() const
 		{
 			return t.getCurrent();
 		}
 
 		// получить заданное время
-		inline timeout_t interval()
+		inline timeout_t interval() const
 		{
 			return t.getInterval();
 		}
 
 		// проверить наступление
-		inline bool check()
+		inline bool check() const
 		{
 			// пока часы не "стоят"
 			// всегда false
@@ -145,7 +145,7 @@ class HourGlass
 			return t.checkTime();
 		}
 
-		inline bool enabled()
+		inline bool enabled() const
 		{
 			return _state;
 		}

include/LogServer.h

@@ -160,7 +160,7 @@ class LogServer:
 		// (они необходимы для восстановления настроек после завершения всех (!) сессий)
 		// т.к. shared_ptr-ов может быть много, то в качестве ключа используем указатель на "реальный объект"(внутри shared_ptr)
 		// но только для этого(!), пользоваться этим указателем ни в коем случае нельзя (и нужно проверять shared_ptr на существование)
-		std::unordered_map< DebugStream*,Debug::type > defaultLogLevels;
+		std::unordered_map< DebugStream*, Debug::type > defaultLogLevels;
 
 		std::string myname = { "LogServer" };
 		std::string addr = { "" };

include/LogSession.h

@@ -41,14 +41,13 @@ class LogSession
 
 		// сигнал о приходе команды: std::string func( LogSession*, command, logname );
 		// \return какую-то информацию, которая будет послана client-у. Если return.empty(), то ничего послано не будет.
-		typedef sigc::signal<std::string,LogSession*,LogServerTypes::Command, const std::string& > LogSessionCommand_Signal;
+		typedef sigc::signal<std::string, LogSession*, LogServerTypes::Command, const std::string& > LogSessionCommand_Signal;
 		LogSessionCommand_Signal signal_logsession_command();
 
-		inline void cancel()
-		{
-			cancelled = true;
-		}
-		inline std::string getClientAddress()
+		// прервать работу
+		void cancel();
+
+		inline std::string getClientAddress() const
 		{
 			return caddr;
 		}
@@ -68,17 +67,13 @@ class LogSession
 
 		//! Установить размер буфера для сообщений (количество записей. Не размер в байтах!!)
 		void setMaxBufSize( size_t num );
-
-		inline size_t getMaxBufSize()
-		{
-			return maxRecordsNum;
-		}
+		size_t getMaxBufSize() const;
 
 		// запуск обработки входящих запросов
 		void run( const ev::loop_ref& loop );
 		void terminate();
 
-		bool isAcive();
+		bool isAcive() const;
 
 		std::string getShortInfo();
 

include/MQAtomic.h

@@ -70,14 +70,14 @@ class MQAtomic
 		 */
 		VoidMessagePtr top();
 
-		size_t size();
-		bool empty();
+		size_t size() const;
+		bool empty() const;
 
 		// ----- Настройки  -----
 		// неявно подразумевается, что всё настривается до первого использования
 		// ----------------------
 		void setMaxSizeOfMessageQueue( size_t s );
-		size_t getMaxSizeOfMessageQueue();
+		size_t getMaxSizeOfMessageQueue() const;
 
 		/*! Стратегия при переполнении */
 		enum LostStrategy

include/MQMutex.h

@@ -56,7 +56,7 @@ class MQMutex
 		// неявно подразумевается, что всё настраивается до первого использования
 		// ----------------------
 		void setMaxSizeOfMessageQueue( size_t s );
-		size_t getMaxSizeOfMessageQueue();
+		size_t getMaxSizeOfMessageQueue() const;
 
 		/*! Стратегия при переполнении */
 		enum LostStrategy

include/ObjectIndex.h

@@ -34,32 +34,32 @@ namespace UniSetTypes
 			virtual ~ObjectIndex() {};
 
 			// info
-			virtual const ObjectInfo* getObjectInfo( const UniSetTypes::ObjectId ) = 0;
-			virtual const ObjectInfo* getObjectInfo( const std::string& name ) = 0;
+			virtual const ObjectInfo* getObjectInfo( const UniSetTypes::ObjectId ) const = 0;
+			virtual const ObjectInfo* getObjectInfo( const std::string& name ) const = 0;
 
 			static std::string getBaseName( const std::string& fname );
 
 			// object id
-			virtual ObjectId getIdByName(const std::string& name) = 0;
-			virtual std::string getNameById( const UniSetTypes::ObjectId id );
+			virtual ObjectId getIdByName(const std::string& name) const = 0;
+			virtual std::string getNameById( const UniSetTypes::ObjectId id ) const;
 
 			// node
-			inline std::string getNodeName( const UniSetTypes::ObjectId id )
+			inline std::string getNodeName( const UniSetTypes::ObjectId id ) const
 			{
 				return getNameById(id);
 			}
 
-			inline ObjectId getNodeId( const std::string& name )
+			inline ObjectId getNodeId( const std::string& name ) const
 			{
 				return getIdByName(name);
 			}
 
 			// src name
-			virtual std::string getMapName( const UniSetTypes::ObjectId id ) = 0;
-			virtual std::string getTextName( const UniSetTypes::ObjectId id ) = 0;
+			virtual std::string getMapName( const UniSetTypes::ObjectId id ) const = 0;
+			virtual std::string getTextName( const UniSetTypes::ObjectId id ) const = 0;
 
 			//
-			virtual std::ostream& printMap(std::ostream& os) = 0;
+			virtual std::ostream& printMap(std::ostream& os) const = 0;
 
 			void initLocalNode( const UniSetTypes::ObjectId nodeid );
 

include/ObjectIndex_Array.h

@@ -42,23 +42,23 @@ namespace UniSetTypes
 			ObjectIndex_Array(const ObjectInfo* objectInfo);
 			virtual ~ObjectIndex_Array();
 
-			virtual const ObjectInfo* getObjectInfo( const ObjectId ) override;
-			virtual const ObjectInfo* getObjectInfo( const std::string& name ) override;
-			virtual ObjectId getIdByName( const std::string& name ) override;
-			virtual std::string getMapName( const ObjectId id ) override;
-			virtual std::string getTextName( const ObjectId id ) override;
+			virtual const ObjectInfo* getObjectInfo( const ObjectId ) const override;
+			virtual const ObjectInfo* getObjectInfo( const std::string& name ) const override;
+			virtual ObjectId getIdByName( const std::string& name ) const override;
+			virtual std::string getMapName( const ObjectId id ) const override;
+			virtual std::string getTextName( const ObjectId id ) const override;
 
-			virtual std::ostream& printMap(std::ostream& os) override;
+			virtual std::ostream& printMap(std::ostream& os) const override;
 			friend std::ostream& operator<<(std::ostream& os, ObjectIndex_Array& oi );
 
 		private:
 
-			int numOfObject;
+			size_t numOfObject;
 			typedef std::unordered_map<std::string, ObjectId> MapObjectKey;
 			MapObjectKey::iterator MapObjectKeyIterator;
 			MapObjectKey mok;
 			const ObjectInfo* objectInfo;
-			int maxId;
+			size_t maxId;
 	};
 	// -----------------------------------------------------------------------------------------
 }    // end of namespace

include/ObjectIndex_XML.h

@@ -36,17 +36,17 @@ namespace UniSetTypes
 		public ObjectIndex
 	{
 		public:
-			ObjectIndex_XML(const std::string& xmlfile, int minSize = 1000 );
-			ObjectIndex_XML( const std::shared_ptr<UniXML>& xml, int minSize = 1000 );
+			ObjectIndex_XML(const std::string& xmlfile, size_t minSize = 1000 );
+			ObjectIndex_XML( const std::shared_ptr<UniXML>& xml, size_t minSize = 1000 );
 			virtual ~ObjectIndex_XML();
 
-			virtual const UniSetTypes::ObjectInfo* getObjectInfo( const ObjectId ) override;
-			virtual const UniSetTypes::ObjectInfo* getObjectInfo( const std::string& name ) override;
-			virtual ObjectId getIdByName( const std::string& name ) override;
-			virtual std::string getMapName( const ObjectId id ) override;
-			virtual std::string getTextName( const ObjectId id ) override;
+			virtual const UniSetTypes::ObjectInfo* getObjectInfo( const ObjectId ) const override;
+			virtual const UniSetTypes::ObjectInfo* getObjectInfo( const std::string& name ) const override;
+			virtual ObjectId getIdByName( const std::string& name ) const override;
+			virtual std::string getMapName( const ObjectId id ) const override;
+			virtual std::string getTextName( const ObjectId id ) const override;
 
-			virtual std::ostream& printMap(std::ostream& os) override;
+			virtual std::ostream& printMap(std::ostream& os) const override;
 			friend std::ostream& operator<<(std::ostream& os, ObjectIndex_XML& oi );
 
 		protected:

include/ObjectIndex_idXML.h

@@ -30,13 +30,13 @@ class ObjectIndex_idXML:
 		ObjectIndex_idXML( const std::shared_ptr<UniXML>& xml );
 		virtual ~ObjectIndex_idXML();
 
-		virtual const UniSetTypes::ObjectInfo* getObjectInfo( const UniSetTypes::ObjectId ) override;
-		virtual const UniSetTypes::ObjectInfo* getObjectInfo( const std::string& name ) override;
-		virtual UniSetTypes::ObjectId getIdByName( const std::string& name ) override;
-		virtual std::string getMapName( const UniSetTypes::ObjectId id ) override;
-		virtual std::string getTextName( const UniSetTypes::ObjectId id ) override;
+		virtual const UniSetTypes::ObjectInfo* getObjectInfo( const UniSetTypes::ObjectId ) const override;
+		virtual const UniSetTypes::ObjectInfo* getObjectInfo( const std::string& name ) const override;
+		virtual UniSetTypes::ObjectId getIdByName( const std::string& name ) const override;
+		virtual std::string getMapName( const UniSetTypes::ObjectId id ) const override;
+		virtual std::string getTextName( const UniSetTypes::ObjectId id ) const override;
 
-		virtual std::ostream& printMap( std::ostream& os ) override;
+		virtual std::ostream& printMap( std::ostream& os ) const override;
 		friend std::ostream& operator<<(std::ostream& os, ObjectIndex_idXML& oi );
 
 	protected:

include/OmniThreadCreator.h

@@ -105,7 +105,7 @@ class OmniThreadCreator:
 		{
 			exit(0);
 		}
-		inline pid_t getTID()
+		inline int getTID()
 		{
 			return id();
 		}

include/Restorer.h

@@ -73,7 +73,6 @@ class Restorer_XML
 		    it     - интератор(указатель) на текущий считываемый xml-узел (<consumer>)
 		    sec    - указатель на текущий узел сообщения (<item>)
 		*/
-
 		void setReadConsumerItem( ReaderSlot sl );
 
 

include/Trigger.h

@@ -69,7 +69,7 @@ class Trigger
 			return false;
 		}
 
-		inline bool get()
+		inline bool get() const
 		{
 			return oldstate;
 		}

include/TriggerAND.h

@@ -82,13 +82,13 @@ class TriggerAND
 		TriggerAND(Caller* r, Action a);
 		~TriggerAND();
 
-		inline bool state()
+		inline bool state() const
 		{
 			return out;
 		}
 
 
-		bool getState(InputType in);
+		bool getState(InputType in) const;
 		bool commit(InputType in, bool state);
 
 		void add(InputType in, bool state);

include/TriggerAND.tcc

@@ -69,9 +69,9 @@ void TriggerAND<Caller,InputType>::remove(InputType num)
 
 //---------------------------------------------------------------------------
 template<class Caller, typename InputType>
-bool TriggerAND<Caller,InputType>::getState(InputType num)
+bool TriggerAND<Caller,InputType>::getState(InputType num) const
 {
-	typename InputMap::iterator it=inputs.find(num);
+	auto it=inputs.find(num);
 	if( it!=inputs.end() )
 		return it->second;
 

include/TriggerOR.h

@@ -81,12 +81,12 @@ class TriggerOR
 		TriggerOR(Caller* r, Action a);
 		~TriggerOR();
 
-		inline bool state()
+		inline bool state() const
 		{
 			return out;
 		}
 
-		bool getState(InputType in);
+		bool getState(InputType in) const;
 		bool commit(InputType in, bool state);
 
 		void add(InputType in, bool state);

include/TriggerOR.tcc

@@ -60,7 +60,7 @@ void TriggerOR<Caller,InputType>::add(InputType num, bool state)
 template<class Caller, typename InputType>
 void TriggerOR<Caller,InputType>::remove(InputType num)
 {
-	typename InputMap::iterator it=inputs.find(num);
+	auto it=inputs.find(num);
 	if( it!=inputs.end() )
 		inputs.erase(it);
 
@@ -69,9 +69,9 @@ void TriggerOR<Caller,InputType>::remove(InputType num)
 
 //---------------------------------------------------------------------------
 template<class Caller, typename InputType>
-bool TriggerOR<Caller,InputType>::getState(InputType num)
+bool TriggerOR<Caller,InputType>::getState(InputType num) const
 {
-	typename InputMap::iterator it=inputs.find(num);
+	auto it=inputs.find(num);
 	if( it!=inputs.end() )
 		return it->second;
 

include/TriggerOUT.h

@@ -94,7 +94,7 @@ class TriggerOUT
 
 
 		/*! получить текущее значение указанного 'выхода' */
-		bool getState(OutIdType out);
+		bool getState(OutIdType out) const;
 
 		/*! установить значение одного из 'выходов'
 		    \param out - идентификатор 'выхода'

include/TriggerOUT.tcc

@@ -57,7 +57,7 @@ void TriggerOUT<Caller,OutIdType,ValueType>::remove(OutIdType num)
 
 //---------------------------------------------------------------------------
 template <class Caller, typename OutIdType, typename ValueType>
-bool TriggerOUT<Caller,OutIdType,ValueType>::getState(OutIdType out)
+bool TriggerOUT<Caller,OutIdType,ValueType>::getState(OutIdType out) const
 {
 	auto it=outs.find(out);
 	if( it!=outs.end() )

include/UDPCore.h

@@ -18,7 +18,7 @@ class UDPSocketU:
 
 		virtual ~UDPSocketU() {}
 
-		inline SOCKET getSocket()
+		inline SOCKET getSocket() const
 		{
 			return ost::UDPSocket::so;
 		}

include/UHelpers.h

@@ -22,99 +22,101 @@
 // --------------------------------------------------------------------------
 namespace UniSetTypes
 {
-// Шаблон для "универсальной инициализации объекта(процесса)".
-// Использование:
-// auto m = make_object<MyClass>("ObjectId","secname");
-// --
-// Где MyClass должен содержать конструктор MyClass( const ObjetctId id, xmlNode* cnode, ...any args.. );
-// ---------------
-// Если secname задан, то ищется: <secname name="ObjectId" ....>
-// Если secname не задан, то: <idname name="idname" ...>
-//----------------
-template<typename T, typename... _Args>
-std::shared_ptr<T> make_object( const std::string& idname, const std::string& secname, _Args&&... __args )
-{
-	auto conf = UniSetTypes::uniset_conf();
-	UniSetTypes::ObjectId id = conf->getObjectID(idname);
+	// Шаблон для "универсальной инициализации объекта(процесса)".
+	// Использование:
+	// auto m = make_object<MyClass>("ObjectId","secname");
+	// --
+	// Где MyClass должен содержать конструктор MyClass( const ObjetctId id, xmlNode* cnode, ...any args.. );
+	// ---------------
+	// Если secname задан, то ищется: <secname name="ObjectId" ....>
+	// Если secname не задан, то: <idname name="idname" ...>
+	//----------------
+	template<typename T, typename... _Args>
+	std::shared_ptr<T> make_object( const std::string& idname, const std::string& secname, _Args&& ... __args )
+	{
+		auto conf = UniSetTypes::uniset_conf();
+		UniSetTypes::ObjectId id = conf->getObjectID(idname);
 
-	if( id == UniSetTypes::DefaultObjectId )
-		throw UniSetTypes::SystemError("(make_object<" + string(typeid(T).name()) + ">): Not found ID for '" + idname + "'");
+		if( id == UniSetTypes::DefaultObjectId )
+			throw UniSetTypes::SystemError("(make_object<" + string(typeid(T).name()) + ">): Not found ID for '" + idname + "'");
 
-	auto xml = conf->getConfXML();
-	std::string s( (secname.empty() ? idname : secname) );
-	xmlNode* cnode = conf->findNode(xml->getFirstNode(),s,idname);
+		auto xml = conf->getConfXML();
+		std::string s( (secname.empty() ? idname : secname) );
+		xmlNode* cnode = conf->findNode(xml->getFirstNode(), s, idname);
 
-	if( cnode == 0 )
-		throw UniSetTypes::SystemError("(make_object<" + string(typeid(T).name()) + ">): Not found xmlnode <" + s + " name='" + idname + "' ... >");
+		if( cnode == 0 )
+			throw UniSetTypes::SystemError("(make_object<" + string(typeid(T).name()) + ">): Not found xmlnode <" + s + " name='" + idname + "' ... >");
 
-	std::shared_ptr<T> obj =std::make_shared<T>(id,cnode,std::forward<_Args>(__args)...);
-	if (obj == nullptr)
-		 throw UniSetTypes::SystemError("(make_object<T>  == nullptr" + string(typeid(T).name()));
-	return obj;
-}
-// -----------------------------------------------------------------------------
-// версия с указанием начального xml-узла, с которого ведётся поиск xmlNode
-// а ID берётся из поля name="" у найденного xmlnode.
-template<typename T, typename... _Args>
-std::shared_ptr<T> make_object_x( xmlNode* root, const std::string& secname, _Args&&... __args )
-{
-	auto conf = UniSetTypes::uniset_conf();
-	auto xml = conf->getConfXML();
-	xmlNode* cnode = conf->findNode(root,secname,"");
+		std::shared_ptr<T> obj = std::make_shared<T>(id, cnode, std::forward<_Args>(__args)...);
 
-	if( cnode == 0 )
-		throw UniSetTypes::SystemError("(make_object_x<" + string(typeid(T).name()) + ">): Not found xmlnode <" + secname + " ... >");
+		if (obj == nullptr)
+			throw UniSetTypes::SystemError("(make_object<T>  == nullptr" + string(typeid(T).name()));
 
-	string idname = conf->getProp(cnode,"name");
-	UniSetTypes::ObjectId id = conf->getObjectID(idname);
+		return obj;
+	}
+	// -----------------------------------------------------------------------------
+	// версия с указанием начального xml-узла, с которого ведётся поиск xmlNode
+	// а ID берётся из поля name="" у найденного xmlnode.
+	template<typename T, typename... _Args>
+	std::shared_ptr<T> make_object_x( xmlNode* root, const std::string& secname, _Args&& ... __args )
+	{
+		auto conf = UniSetTypes::uniset_conf();
+		auto xml = conf->getConfXML();
+		xmlNode* cnode = conf->findNode(root, secname, "");
 
-	if( id == UniSetTypes::DefaultObjectId )
-		throw UniSetTypes::SystemError("(make_object_x<" + string(typeid(T).name()) + ">): Not found ID for '" + idname + "'");
+		if( cnode == 0 )
+			throw UniSetTypes::SystemError("(make_object_x<" + string(typeid(T).name()) + ">): Not found xmlnode <" + secname + " ... >");
 
-	return std::make_shared<T>(id,cnode,std::forward<_Args>(__args)...);
+		string idname = conf->getProp(cnode, "name");
+		UniSetTypes::ObjectId id = conf->getObjectID(idname);
+
+		if( id == UniSetTypes::DefaultObjectId )
+			throw UniSetTypes::SystemError("(make_object_x<" + string(typeid(T).name()) + ">): Not found ID for '" + idname + "'");
+
+		return std::make_shared<T>(id, cnode, std::forward<_Args>(__args)...);
 
-}
-// -----------------------------------------------------------------------------
-// Просто обёртка для удобства вывода сообщений об ошибке в лог "объекта"..
-// "по задумке" позволяет не загромаждать код..
-// T - тип создаваемого объекта
-// M - (master) - класс который создаёт объект (подразумевается, что он UniSetManager)
-template<typename T, typename M, typename... _Args>
-std::shared_ptr<T> make_child_object( M* m, const std::string& idname, const std::string& secname, _Args&&... __args )
-{
-	try
-	{
-		m->log()->info() << m->getName() << "(" << __FUNCTION__ << "): " << "create " << idname << "..." << std::endl;
-		auto o = UniSetTypes::make_object<T>(idname,secname,std::forward<_Args>(__args)...);
-		m->add(o);
-		m->logAgregator()->add(o->logAgregator());
-		return std::move(o);
-	}
-	catch( const UniSetTypes::Exception& ex )
-	{
-		m->log()->crit() << m->getName() << "(" << __FUNCTION__ << "): " << "(create " << idname << "): " << ex << std::endl;
-		throw;
 	}
-}
-// -----------------------------------------------------------------------------
-// Версия использующая make_object_x<>
-template<typename T, typename M, typename... _Args>
-std::shared_ptr<T> make_child_object_x( M* m, xmlNode* root, const std::string& secname, _Args&&... __args )
-{
-	try
+	// -----------------------------------------------------------------------------
+	// Просто обёртка для удобства вывода сообщений об ошибке в лог "объекта"..
+	// "по задумке" позволяет не загромаждать код..
+	// T - тип создаваемого объекта
+	// M - (master) - класс который создаёт объект (подразумевается, что он UniSetManager)
+	template<typename T, typename M, typename... _Args>
+	std::shared_ptr<T> make_child_object( M* m, const std::string& idname, const std::string& secname, _Args&& ... __args )
 	{
-		auto o = UniSetTypes::make_object_x<T>(root,secname,std::forward<_Args>(__args)...);
-		m->add(o);
-		m->logAgregator()->add(o->logAgregator());
-		return std::move(o);
+		try
+		{
+			m->log()->info() << m->getName() << "(" << __FUNCTION__ << "): " << "create " << idname << "..." << std::endl;
+			auto o = UniSetTypes::make_object<T>(idname, secname, std::forward<_Args>(__args)...);
+			m->add(o);
+			m->logAgregator()->add(o->logAgregator());
+			return std::move(o);
+		}
+		catch( const UniSetTypes::Exception& ex )
+		{
+			m->log()->crit() << m->getName() << "(" << __FUNCTION__ << "): " << "(create " << idname << "): " << ex << std::endl;
+			throw;
+		}
 	}
-	catch( const UniSetTypes::Exception& ex )
+	// -----------------------------------------------------------------------------
+	// Версия использующая make_object_x<>
+	template<typename T, typename M, typename... _Args>
+	std::shared_ptr<T> make_child_object_x( M* m, xmlNode* root, const std::string& secname, _Args&& ... __args )
 	{
-		m->log()->crit() << m->getName() << "(" << __FUNCTION__ << "): " << "(create " << string(typeid(T).name()) << "): " << ex << std::endl;
-		throw;
+		try
+		{
+			auto o = UniSetTypes::make_object_x<T>(root, secname, std::forward<_Args>(__args)...);
+			m->add(o);
+			m->logAgregator()->add(o->logAgregator());
+			return std::move(o);
+		}
+		catch( const UniSetTypes::Exception& ex )
+		{
+			m->log()->crit() << m->getName() << "(" << __FUNCTION__ << "): " << "(create " << string(typeid(T).name()) << "): " << ex << std::endl;
+			throw;
+		}
 	}
-}
-// -----------------------------------------------------------------------------------------
+	// -----------------------------------------------------------------------------------------
 } // endof namespace UniSetTypes
 // -----------------------------------------------------------------------------------------
 #endif // UHelpers_H_

include/UniSetActivator.h

@@ -76,7 +76,7 @@ class UniSetActivator:
 		typedef sigc::signal<void, int> TerminateEvent_Signal;
 		TerminateEvent_Signal signal_terminate_event();
 
-		inline bool noUseGdbForStackTrace()
+		inline bool noUseGdbForStackTrace() const
 		{
 			return _noUseGdbForStackTrace;
 		}
@@ -120,7 +120,7 @@ class UniSetActivator:
 		TerminateEvent_Signal s_term;
 
 		std::atomic_bool omDestroy;
-		pid_t thpid; // pid orb потока
+		pid_t thid; // id orb потока
 
 		bool _noUseGdbForStackTrace = { false };
 

include/UniXML.h

@@ -187,7 +187,7 @@ class UniXML
 		void open(const std::string& filename);
 
 		void close();
-		inline bool isOpen()
+		inline bool isOpen() const
 		{
 			return doc != 0;
 		}
@@ -198,7 +198,7 @@ class UniXML
 		~UniXML();
 
 		xmlDoc* doc;
-		inline std::string getFileName()
+		inline std::string getFileName() const
 		{
 			return filename;
 		}

include/modbus/ModbusClient.h

@@ -150,12 +150,11 @@ class ModbusClient
 		void initLog( std::shared_ptr<UniSetTypes::Configuration> conf, const std::string& name, const std::string& logfile = "" );
 		void setLog( std::shared_ptr<DebugStream> dlog );
 
-
 		inline void setCRCNoCheckit( bool set )
 		{
 			crcNoCheckit = set;
 		}
-		inline bool isCRCNoCheckit()
+		inline bool isCRCNoCheckit() const
 		{
 			return crcNoCheckit;
 		}

include/modbus/ModbusRTUSlave.h

@@ -39,7 +39,7 @@ class ModbusRTUSlave:
 		}
 
 		virtual void terminate() override;
-		virtual bool isActive() override;
+		virtual bool isActive() const override;
 
 	protected:
 

include/modbus/ModbusServer.h

@@ -21,7 +21,7 @@ namespace std
 		public:
 			size_t operator()(const ModbusRTU::mbErrCode& e) const
 			{
-				return std::hash<int>()(e);
+				return std::hash<size_t>()(e);
 			}
 	};
 }
@@ -98,7 +98,7 @@ class ModbusServer
 		{
 			crcNoCheckit = set;
 		}
-		inline bool isCRCNoCheckit()
+		inline bool isCRCNoCheckit() const
 		{
 			return crcNoCheckit;
 		}
@@ -107,7 +107,7 @@ class ModbusServer
 		{
 			onBroadcast = set;
 		}
-		inline bool getBroadcastMode()
+		inline bool getBroadcastMode() const
 		{
 			return onBroadcast;
 		}
@@ -142,7 +142,7 @@ class ModbusServer
 		virtual void cleanupChannel() {}
 		virtual void terminate() {}
 
-		virtual bool isActive() = 0;
+		virtual bool isActive() const = 0;
 
 		// ------------ Статистика ---------------
 		typedef std::unordered_map<ModbusRTU::mbErrCode, size_t> ExchangeErrorMap;
@@ -151,7 +151,7 @@ class ModbusServer
 		size_t getErrCount( ModbusRTU::mbErrCode e );
 		size_t resetErrCount( ModbusRTU::mbErrCode e, size_t set = 0 );
 
-		inline size_t getAskCount()
+		inline size_t getAskCount() const
 		{
 			return askCount;
 		}

include/modbus/ModbusTCPMaster.h

@@ -22,7 +22,7 @@ class ModbusTCPMaster:
 		void connect( ost::InetAddress addr, int port );
 		void disconnect();
 		void forceDisconnect();
-		bool isConnection();
+		bool isConnection() const;
 
 		static bool checkConnection( const std::string& ip, int port, int timeout_msec = 100 );
 
@@ -39,11 +39,11 @@ class ModbusTCPMaster:
 			cleanInputStream();
 		}
 
-		inline std::string getAddress()
+		inline std::string getAddress() const
 		{
 			return iaddr;
 		}
-		inline int getPort()
+		inline int getPort() const
 		{
 			return port;
 		}

include/modbus/ModbusTCPServer.h

@@ -37,7 +37,7 @@ class ModbusTCPServer:
 		 */
 		void run( const std::unordered_set<ModbusRTU::ModbusAddr>& vmbaddr, bool thread = false );
 
-		virtual bool isActive() override;
+		virtual bool isActive() const override;
 
 		void setMaxSessions( size_t num );
 		inline size_t getMaxSessions()

include/modbus/ModbusTCPSession.h

@@ -45,7 +45,7 @@ class ModbusTCPSession:
 
 		void connectFinalSession( FinalSlot sl );
 
-		inline std::string getClientAddress()
+		inline std::string getClientAddress() const
 		{
 			return caddr;
 		}
@@ -55,7 +55,7 @@ class ModbusTCPSession:
 		// запуск обработки входящих запросов
 		void run( ev::loop_ref& loop );
 
-		virtual bool isActive() override;
+		virtual bool isActive() const override;
 
 		void iowait( timeout_t msec );
 

include/modbus/ModbusTypes.h

@@ -192,16 +192,31 @@ namespace ModbusRTU
 		ModbusMessage( const ModbusMessage& ) = default;
 		ModbusMessage& operator=(const ModbusMessage& ) = default;
 
-		inline ModbusByte func() const { return pduhead.func; }
-		inline ModbusAddr addr() const { return pduhead.addr; }
-		inline ModbusRTU::ModbusData tID() const { return aduhead.tID; }
-		inline ModbusRTU::ModbusData pID() const { return aduhead.pID; }
-		inline ModbusRTU::ModbusData aduLen() const { return aduhead.len; }
+		inline ModbusByte func() const
+		{
+			return pduhead.func;
+		}
+		inline ModbusAddr addr() const
+		{
+			return pduhead.addr;
+		}
+		inline ModbusRTU::ModbusData tID() const
+		{
+			return aduhead.tID;
+		}
+		inline ModbusRTU::ModbusData pID() const
+		{
+			return aduhead.pID;
+		}
+		inline ModbusRTU::ModbusData aduLen() const
+		{
+			return aduhead.len;
+		}
 
 		unsigned char* buf();
 		ModbusRTU::ModbusData len() const;
 		void swapHead();
-		void makeHead( ModbusRTU::ModbusData tID, bool noCRC = true, ModbusRTU::ModbusData pID=0 );
+		void makeHead( ModbusRTU::ModbusData tID, bool noCRC = true, ModbusRTU::ModbusData pID = 0 );
 
 		ModbusRTU::ModbusData pduLen() const;
 		ModbusCRC pduCRC( size_t len ) const;
@@ -285,7 +300,7 @@ namespace ModbusRTU
 		const DataBits16& operator=(const ModbusData& r);
 
 		operator ModbusData();
-		ModbusData mdata();
+		ModbusData mdata() const;
 
 		bool operator[]( const size_t i )
 		{
@@ -344,6 +359,7 @@ namespace ModbusRTU
 		ReadCoilRetMessage( const ModbusMessage& m );
 		ReadCoilRetMessage& operator=( const ModbusMessage& m );
 		void init( const ModbusMessage& m );
+
 		/*! размер предварительного заголовка
 		 * (после основного до фактических данных)
 		*/
@@ -380,19 +396,19 @@ namespace ModbusRTU
 		 * \return TRUE - если есть
 		 * \return FALSE - если НЕ найдено
 		*/
-		bool getData( unsigned char bnum, DataBits& d );
+		bool getData( unsigned char bnum, DataBits& d ) const;
 
 		/*! очистка данных */
 		void clear();
 
 		/*! проверка на переполнение */
-		inline bool isFull()
+		inline bool isFull() const
 		{
 			return ( (int)bcnt >= MAXPDULEN );
 		}
 
 		/*! размер данных(после заголовка) у данного типа сообщения */
-		size_t szData();
+		size_t szData() const;
 
 		/*! преобразование для посылки в сеть */
 		ModbusMessage transport_msg();
@@ -411,12 +427,14 @@ namespace ModbusRTU
 
 		// ------- to slave -------
 		ReadInputStatusMessage( ModbusAddr addr, ModbusData start, ModbusData count );
+
 		/*! преобразование для посылки в сеть */
 		ModbusMessage transport_msg();
 
 		// ------- from master -------
 		ReadInputStatusMessage( const ModbusMessage& m );
 		ReadInputStatusMessage& operator=( const ModbusMessage& m );
+
 		void init( const ModbusMessage& m );
 
 		/*! размер данных(после заголовка) у данного типа сообщения */
@@ -441,6 +459,7 @@ namespace ModbusRTU
 		ReadInputStatusRetMessage( const ModbusMessage& m );
 		ReadInputStatusRetMessage& operator=( const ModbusMessage& m );
 		void init( const ModbusMessage& m );
+
 		/*! размер предварительного заголовка
 		 * (после основного до фактических данных)
 		*/
@@ -477,19 +496,19 @@ namespace ModbusRTU
 		 * \return TRUE - если есть
 		 * \return FALSE - если НЕ найдено
 		*/
-		bool getData( unsigned char dnum, DataBits& d );
+		bool getData( unsigned char dnum, DataBits& d ) const;
 
 		/*! очистка данных */
 		void clear();
 
 		/*! проверка на переполнение */
-		inline bool isFull()
+		inline bool isFull() const
 		{
 			return ( (int)bcnt >= MAXPDULEN );
 		}
 
 		/*! размер данных(после заголовка) у данного типа сообщения */
-		size_t szData();
+		size_t szData() const;
 
 		/*! преобразование для посылки в сеть */
 		ModbusMessage transport_msg();
@@ -565,13 +584,13 @@ namespace ModbusRTU
 		void clear();
 
 		/*! проверка на переполнение */
-		inline bool isFull()
+		inline bool isFull() const
 		{
 			return ( count * sizeof(ModbusData) >= MAXLENPACKET );
 		}
 
 		/*! размер данных(после заголовка) у данного типа сообщения */
-		size_t szData();
+		size_t szData() const;
 
 		/*! преобразование для посылки в сеть */
 		ModbusMessage transport_msg();
@@ -654,7 +673,7 @@ namespace ModbusRTU
 		void clear();
 
 		/*! проверка на переполнение */
-		inline bool isFull()
+		inline bool isFull() const
 		{
 			return ( count * sizeof(ModbusData) >= MAXLENPACKET );
 		}
@@ -706,7 +725,7 @@ namespace ModbusRTU
 
 		bool setBit( int nbit, bool state );
 
-		inline int last()
+		inline size_t last() const
 		{
 			return quant;
 		}
@@ -722,7 +741,7 @@ namespace ModbusRTU
 		bool getBit( unsigned char bnum );
 
 		void clear();
-		inline bool isFull()
+		inline bool isFull() const
 		{
 			return ( (int)bcnt >= MAXPDULEN );
 		}
@@ -733,7 +752,7 @@ namespace ModbusRTU
 		void init( const ModbusMessage& m );
 
 		/*! размер данных(после заголовка) у данного типа сообщения */
-		size_t szData();
+		size_t szData() const;
 
 		/*! размер предварительного заголовка
 		 * (после основного до фактических данных)
@@ -750,7 +769,7 @@ namespace ModbusRTU
 		/*! проверка корректности данных
 		    что quant и bcnt - совпадают...
 		*/
-		bool checkFormat();
+		bool checkFormat() const;
 
 	} __attribute__((packed));
 
@@ -815,7 +834,7 @@ namespace ModbusRTU
 
 		bool addData( ModbusData d );
 		void clear();
-		inline bool isFull()
+		inline bool isFull() const
 		{
 			return ( quant >= MAXDATALEN );
 		}
@@ -826,7 +845,7 @@ namespace ModbusRTU
 		void init( const ModbusMessage& m );
 
 		/*! размер данных(после заголовка) у данного типа сообщения */
-		size_t szData();
+		size_t szData() const;
 
 		/*! размер предварительного заголовка
 		 * (после основного до фактических данных)
@@ -843,7 +862,7 @@ namespace ModbusRTU
 		/*! проверка корректности данных
 		    что quant и bcnt - совпадают...
 		*/
-		bool checkFormat();
+		bool checkFormat() const;
 
 	} __attribute__((packed));
 
@@ -915,7 +934,7 @@ namespace ModbusRTU
 		void init( const ModbusMessage& m );
 
 		/*! размер данных(после заголовка) у данного типа сообщения */
-		size_t szData();
+		size_t szData() const;
 
 		/*! размер предварительного заголовка
 		 * (после основного до фактических данных)
@@ -933,7 +952,7 @@ namespace ModbusRTU
 		/*! проверка корректности данных
 		    что quant и bcnt - совпадают...
 		*/
-		bool checkFormat();
+		bool checkFormat() const;
 	} __attribute__((packed));
 
 
@@ -950,7 +969,7 @@ namespace ModbusRTU
 		ModbusCRC crc = { 0 };
 
 		/*! получить значение команды */
-		inline bool cmd()
+		inline bool cmd() const
 		{
 			return (data & 0xFF00);
 		}
@@ -1006,7 +1025,7 @@ namespace ModbusRTU
 		void init( const ModbusMessage& m );
 
 		/*! размер данных(после заголовка) у данного типа сообщения */
-		size_t szData();
+		size_t szData() const;
 
 		/*! размер предварительного заголовка
 		 * (после основного до фактических данных)
@@ -1107,14 +1126,14 @@ namespace ModbusRTU
 		void clear();
 
 		/*! проверка на переполнение */
-		inline bool isFull()
+		inline bool isFull() const
 		{
 			// (1)subf + data count
 			return ( 1 + count >= MAXDATALEN );
 		}
 
 		/*! размер данных(после заголовка) у данного типа сообщения */
-		size_t szData();
+		size_t szData() const;
 
 		/*! преобразование для посылки в сеть */
 		ModbusMessage transport_msg();
@@ -1176,7 +1195,7 @@ namespace ModbusRTU
 		}
 
 		// вспомогательные функции
-		bool checkFormat();
+		bool checkFormat() const;
 
 	} __attribute__((packed));
 	// -----------------------------------------------------------------------
@@ -1242,18 +1261,18 @@ namespace ModbusRTU
 		void clear();
 
 		/*! проверка на переполнение */
-		inline bool isFull()
+		inline bool isFull() const
 		{
 			return ( bcnt >= MAXPDULEN );
 		}
 
 		/*! размер данных(после заголовка) у данного типа сообщения */
-		size_t szData();
+		size_t szData() const;
 
 		/*! преобразование для посылки в сеть */
 		ModbusMessage transport_msg();
 
-		int bcnt = { 0 }; /*! размер данных в байтах, внутреннее служебное поле */
+		size_t bcnt = { 0 }; /*! размер данных в байтах, внутреннее служебное поле */
 	};
 
 	std::ostream& operator<<(std::ostream& os, MEIMessageRetRDI& m );
@@ -1313,13 +1332,13 @@ namespace ModbusRTU
 		void clear();
 
 		/*! проверка на переполнение */
-		inline bool isFull()
+		inline bool isFull() const
 		{
 			return ( count >= MAXDATALEN );
 		}
 
 		/*! размер данных(после заголовка) у данного типа сообщения */
-		size_t szData();
+		size_t szData() const;
 
 		/*! преобразование для посылки в сеть */
 		ModbusMessage transport_msg();
@@ -1375,7 +1394,7 @@ namespace ModbusRTU
 		SetDateTimeMessage& operator=( const ModbusMessage& m );
 		SetDateTimeMessage();
 
-		bool checkFormat();
+		bool checkFormat() const;
 
 		/*! размер данных(после заголовка) у данного типа сообщения */
 		inline static size_t szData()
@@ -1425,7 +1444,7 @@ namespace ModbusRTU
 		void init( const ModbusMessage& m );
 
 		/*! размер данных(после заголовка) у данного типа сообщения */
-		size_t szData();
+		size_t szData() const;
 
 		/*! размер предварительного заголовка
 		 * (после основного до фактических данных)
@@ -1464,13 +1483,13 @@ namespace ModbusRTU
 		void clear();
 
 		/*! проверка на переполнение */
-		inline bool isFull()
+		inline bool isFull() const
 		{
 			return ( count >= sizeof(data) );
 		}
 
 		/*! размер данных(после заголовка) у данного типа сообщения */
-		size_t szData();
+		size_t szData() const;
 
 		/*! преобразование для посылки в сеть */
 		ModbusMessage transport_msg();
@@ -1505,7 +1524,7 @@ namespace ModbusRTU
 		void init( const ModbusMessage& m );
 
 		/*! размер данных(после заголовка) у данного типа сообщения */
-		size_t szData();
+		size_t szData() const;
 
 		/*! размер предварительного заголовка
 		 * (после основного до фактических данных)
@@ -1519,7 +1538,7 @@ namespace ModbusRTU
 		static size_t getDataLen( const ModbusMessage& m );
 
 		/*! проверка корректности данных */
-		bool checkFormat();
+		bool checkFormat() const;
 
 		// это поле служебное и не используется в релальном обмене
 		size_t count = { 0 }; /*!< фактическое количество данных */
@@ -1595,7 +1614,7 @@ namespace ModbusRTU
 		void clear();
 
 		/*! размер данных(после заголовка) у данного типа сообщения */
-		size_t szData();
+		size_t szData() const;
 
 		/*! преобразование для посылки в сеть */
 		ModbusMessage transport_msg();

src/Communications/Modbus/ModbusClient.cc

@@ -843,7 +843,7 @@ mbErrCode ModbusClient::recv_pdu( ModbusByte qfunc, ModbusMessage& rbuf, timeout
 			// от начала(включая заголовок)
 			// и до конца (исключив последний элемент содержащий CRC)
 			// int mlen = szModbusHeader + mWrite.szHead()+ mWrite.bcnt;
-			ModbusData tcrc =rbuf.pduCRC(bcnt - szCRC);
+			ModbusData tcrc = rbuf.pduCRC(bcnt - szCRC);
 
 			if( tcrc != mWrite.crc )
 			{
@@ -1335,6 +1335,7 @@ mbErrCode ModbusClient::send( ModbusMessage& msg )
 		if( dlog->is_warn() )
 			dlog->warn() << "(ModbusClient::send): message len=" << msg.len()
 						 << " > MAXLEN=" << msg.maxSizeOfMessage() << endl;
+
 		return erPacketTooLong;
 	}
 
@@ -1345,7 +1346,7 @@ mbErrCode ModbusClient::send( ModbusMessage& msg )
 	{
 		size_t len = msg.len(); // т.к. swapHead() поменяет
 		msg.swapHead();
-		sendData(msg.buf(),len);
+		sendData(msg.buf(), len);
 		msg.swapHead();
 	}
 	catch( mbException& ex )

src/Communications/Modbus/ModbusRTUSlave.cc

@@ -139,7 +139,7 @@ void ModbusRTUSlave::terminate()
 	catch(...) {}
 }
 // -------------------------------------------------------------------------
-bool ModbusRTUSlave::isActive()
+bool ModbusRTUSlave::isActive() const
 {
 	return false;
 }
@@ -154,7 +154,7 @@ mbErrCode ModbusRTUSlave::realReceive(const std::unordered_set<ModbusAddr>& vmba
 		return erTimeOut;
 	}
 
-	std::lock_guard<std::timed_mutex> lk(recvMutex,std::adopt_lock);
+	std::lock_guard<std::timed_mutex> lk(recvMutex, std::adopt_lock);
 
 	ModbusMessage buf;
 	mbErrCode res = erBadReplyNodeAddress;

src/Communications/Modbus/ModbusServer.cc

@@ -1767,7 +1767,7 @@ mbErrCode ModbusServer::send( ModbusMessage& msg )
 	{
 		size_t len = msg.len(); // т.к. swapHead() поменяет
 		msg.swapHead();
-		sendData(msg.buf(),len);
+		sendData(msg.buf(), len);
 		msg.swapHead(); // обратно, т.к. потом ещё будет post_send_request
 	}
 	catch( const Exception& ex ) // SystemError

src/Communications/Modbus/ModbusTCPCore.cc

@@ -32,16 +32,17 @@ size_t ModbusTCPCore::readNextData(UTCPStream* tcp,
 #ifdef USE_BUFFER_FOR_READ
 
 	char* buf = new char[max];
+
 	if( buf == 0 )
 		return 0;
 
 	try
 	{
-		ssize_t l = tcp->readData(buf,max, 0, t);
+		ssize_t l = tcp->readData(buf, max, 0, t);
 
 		if( l > 0 )
 		{
-			for( ssize_t k=0; k<l; k++ )
+			for( ssize_t k = 0; k < l; k++ )
 				qrecv.push(buf[k]);
 
 			i = l;
@@ -53,6 +54,7 @@ size_t ModbusTCPCore::readNextData(UTCPStream* tcp,
 
 	delete [] buf;
 #else
+
 	try
 	{
 		for( ; i < max; i++ )
@@ -70,6 +72,7 @@ size_t ModbusTCPCore::readNextData(UTCPStream* tcp,
 	catch( ost::SockException& e )
 	{
 	}
+
 #endif
 
 
@@ -128,6 +131,7 @@ size_t ModbusTCPCore::readDataFD( int fd, std::queue<unsigned char>& qrecv, size
 				qrecv.push(buf[k]);
 
 			cnt += l;
+
 			if( cnt >= max )
 				break;
 		}
@@ -137,6 +141,7 @@ size_t ModbusTCPCore::readDataFD( int fd, std::queue<unsigned char>& qrecv, size
 #else
 
 	size_t i = 0;
+
 	for( size_t a = 0; a < attempts; a++ )
 	{
 		for( ; i < max; i++ )
@@ -151,6 +156,7 @@ size_t ModbusTCPCore::readDataFD( int fd, std::queue<unsigned char>& qrecv, size
 			qrecv.push(c);
 		}
 	}
+
 #endif
 
 	return ( qrecv.size() >= max ? max : qrecv.size() );

src/Communications/Modbus/ModbusTCPMaster.cc

@@ -102,7 +102,7 @@ mbErrCode ModbusTCPMaster::query( ModbusAddr addr, ModbusMessage& msg,
 
 		tcp->setTimeout(timeout);
 
-		msg.makeHead(++nTransaction,crcNoCheckit);
+		msg.makeHead(++nTransaction, crcNoCheckit);
 
 		for( unsigned int i = 0; i < 2; i++ )
 		{
@@ -157,6 +157,7 @@ mbErrCode ModbusTCPMaster::query( ModbusAddr addr, ModbusMessage& msg,
 		if( tcp->isPending(ost::Socket::pendingInput, timeout) )
 		{
 			size_t ret = 0;
+
 			while( !ptTimeout.checkTime() )
 			{
 				ret = getNextData((unsigned char*)(&reply.aduhead), sizeof(reply.aduhead));
@@ -186,11 +187,11 @@ mbErrCode ModbusTCPMaster::query( ModbusAddr addr, ModbusMessage& msg,
 					try
 					{
 						dlog->warn() << "(ModbusTCPMaster::query): ret=" << ret
-								 << " < rmh=" << sizeof(reply.aduhead)
-								 << " errnum: " << tcp->getErrorNumber()
-								 << " perr: " << tcp->getPeer(&port)
-								 << " err: " << (err ? string(err) : "")
-								 << endl;
+									 << " < rmh=" << sizeof(reply.aduhead)
+									 << " errnum: " << tcp->getErrorNumber()
+									 << " perr: " << tcp->getPeer(&port)
+									 << " err: " << (err ? string(err) : "")
+									 << endl;
 					}
 					catch( const ost::SockException& e )
 					{
@@ -208,15 +209,15 @@ mbErrCode ModbusTCPMaster::query( ModbusAddr addr, ModbusMessage& msg,
 
 			if( dlog->is_level9() )
 				dlog->level9() << "(ModbusTCPMaster::query): ADU len=" << reply.aduLen()
-							 << endl;
+							   << endl;
 
 			if( reply.tID() != msg.tID() )
 			{
 				if( dlog->is_warn() )
 					dlog->warn() << "(ModbusTCPMaster::query): tID=" << reply.tID()
-						<< " != " << msg.tID()
-						<< " (len=" << reply.len() << ")"
-						<< endl;
+								 << " != " << msg.tID()
+								 << " (len=" << reply.len() << ")"
+								 << endl;
 
 				cleanInputStream();
 				return  erBadReplyNodeAddress;
@@ -459,7 +460,7 @@ void ModbusTCPMaster::forceDisconnect()
 	tcp.reset();
 }
 // -------------------------------------------------------------------------
-bool ModbusTCPMaster::isConnection()
+bool ModbusTCPMaster::isConnection() const
 {
 	return tcp && tcp->isConnected();
 }

src/Communications/Modbus/ModbusTCPServer.cc

@@ -83,7 +83,7 @@ void ModbusTCPServer::run( const std::unordered_set<ModbusAddr>& _vmbaddr, bool
 	evrun(thread);
 }
 // -------------------------------------------------------------------------
-bool ModbusTCPServer::isActive()
+bool ModbusTCPServer::isActive() const
 {
 	return evIsActive();
 }

src/Communications/Modbus/ModbusTCPSession.cc

@@ -61,8 +61,10 @@ ModbusTCPSession::ModbusTCPSession( int sfd, const std::unordered_set<ModbusAddr
 		{
 			ostringstream err;
 			err << "(ModbusTCPSession): unknonwn ip(0.0.0.0) client disconnected?!";
+
 			if( dlog->is_crit() )
 				dlog->crit() << err.str() << endl;
+
 			sock.reset();
 			throw SystemError(err.str());
 		}
@@ -76,6 +78,7 @@ ModbusTCPSession::ModbusTCPSession( int sfd, const std::unordered_set<ModbusAddr
 	{
 		ostringstream err;
 		err << ex.what();
+
 		if( dlog->is_crit() )
 			dlog->crit() << "(ModbusTCPSession): err: " << err.str() << endl;
 
@@ -123,7 +126,7 @@ void ModbusTCPSession::run( ev::loop_ref& loop )
 	ioTimeout.start(sessTimeout);
 }
 // -------------------------------------------------------------------------
-bool ModbusTCPSession::isActive()
+bool ModbusTCPSession::isActive() const
 {
 	return io.is_active();
 }
@@ -381,7 +384,7 @@ ModbusRTU::mbErrCode ModbusTCPSession::post_send_request( ModbusRTU::ModbusMessa
 // -------------------------------------------------------------------------
 mbErrCode ModbusTCPSession::make_adu_header( ModbusMessage& req )
 {
-	req.makeHead(curQueryHeader.tID,isCRCNoCheckit(),curQueryHeader.pID);
+	req.makeHead(curQueryHeader.tID, isCRCNoCheckit(), curQueryHeader.pID);
 	return erNoError;
 }
 // -------------------------------------------------------------------------

src/Communications/Modbus/ModbusTypes.cc

@@ -256,6 +256,7 @@ void ModbusMessage::makeHead( ModbusData tID, bool noCRC, ModbusData pID )
 	aduhead.tID = tID;
 	aduhead.pID = pID;
 	aduhead.len = pduLen();
+
 	if( noCRC )
 		aduhead.len -= szCRC;
 }
@@ -283,12 +284,14 @@ void ModbusMessage::clear()
 std::ostream& ModbusRTU::operator<<(std::ostream& os, const ModbusMessage& m )
 {
 	os << m.aduhead << "| ";
+
 	if( m.aduLen() == 0 )
 		mbPrintMessage(os, (ModbusByte*)(&m.pduhead), sizeof(m.pduhead) + m.dlen);
 	else
 		mbPrintMessage(os, (ModbusByte*)(&m.pduhead), m.aduLen());
+
 	return os;
-//	return mbPrintMessage(os, (ModbusByte*)(&m), sizeof(m.aduhead) + sizeof(m.pduhead) + m.dlen);
+	//	return mbPrintMessage(os, (ModbusByte*)(&m), sizeof(m.aduhead) + sizeof(m.pduhead) + m.dlen);
 }
 
 std::ostream& ModbusRTU::operator<<(std::ostream& os, const ModbusMessage* m )
@@ -410,7 +413,7 @@ ReadCoilMessage& ReadCoilMessage::operator=( const ModbusMessage& m )
 void ReadCoilMessage::init( const ModbusMessage& m )
 {
 	assert( m.pduhead.func == fnReadCoilStatus );
-//	memset(this, 0, sizeof(*this));
+	//	memset(this, 0, sizeof(*this));
 	memcpy(this, &m.pduhead, sizeof(m.pduhead));
 	memcpy(&start, m.data, szData());
 
@@ -512,7 +515,7 @@ DataBits16::operator ModbusData()
 	return mdata();
 }
 // -------------------------------------------------------------------------
-ModbusData DataBits16::mdata()
+ModbusData DataBits16::mdata() const
 {
 	ModbusData udata = 0;
 
@@ -618,7 +621,7 @@ bool ReadCoilRetMessage::addData( DataBits d )
 	return true;
 }
 // -------------------------------------------------------------------------
-bool ReadCoilRetMessage::getData( unsigned char dnum, DataBits& d )
+bool ReadCoilRetMessage::getData( unsigned char dnum, DataBits& d ) const
 {
 	if( dnum < bcnt )
 	{
@@ -663,7 +666,7 @@ ModbusMessage ReadCoilRetMessage::transport_msg()
 	return std::move(mm);
 }
 // -------------------------------------------------------------------------
-size_t ReadCoilRetMessage::szData()
+size_t ReadCoilRetMessage::szData() const
 {
 	// фактическое число данных + контрольная сумма
 	return sizeof(bcnt) + bcnt + szCRC;
@@ -730,7 +733,7 @@ ReadInputStatusMessage& ReadInputStatusMessage::operator=( const ModbusMessage&
 void ReadInputStatusMessage::init( const ModbusMessage& m )
 {
 	assert( m.pduhead.func == fnReadInputStatus );
-	memcpy(this, &m.pduhead, sizeof(m.pduhead)+szData());
+	memcpy(this, &m.pduhead, sizeof(m.pduhead) + szData());
 
 	// переворачиваем слова
 	start = SWAPSHORT(start);
@@ -819,7 +822,7 @@ bool ReadInputStatusRetMessage::addData( DataBits d )
 	return true;
 }
 // -------------------------------------------------------------------------
-bool ReadInputStatusRetMessage::getData( unsigned char dnum, DataBits& d )
+bool ReadInputStatusRetMessage::getData( unsigned char dnum, DataBits& d ) const
 {
 	if( dnum < bcnt )
 	{
@@ -864,7 +867,7 @@ ModbusMessage ReadInputStatusRetMessage::transport_msg()
 	return std::move(mm);
 }
 // -------------------------------------------------------------------------
-size_t ReadInputStatusRetMessage::szData()
+size_t ReadInputStatusRetMessage::szData() const
 {
 	// фактическое число данных + контрольная сумма
 	return sizeof(bcnt) + bcnt + szCRC;
@@ -935,7 +938,7 @@ void ReadOutputMessage::init( const ModbusMessage& m )
 {
 	assert( m.pduhead.func == fnReadOutputRegisters );
 	//memset(this, 0, sizeof(*this));
-	memcpy(this, &m.pduhead, sizeof(m.pduhead)+szData());
+	memcpy(this, &m.pduhead, sizeof(m.pduhead) + szData());
 
 	// переворачиваем слова
 	start = SWAPSHORT(start);
@@ -1074,7 +1077,7 @@ ModbusMessage ReadOutputRetMessage::transport_msg()
 	return std::move(mm);
 }
 // -------------------------------------------------------------------------
-size_t ReadOutputRetMessage::szData()
+size_t ReadOutputRetMessage::szData() const
 {
 	// фактическое число данных + контрольная сумма
 	return sizeof(bcnt) + count * sizeof(ModbusData) + szCRC;
@@ -1142,9 +1145,9 @@ ReadInputMessage& ReadInputMessage::operator=( const ModbusMessage& m )
 void ReadInputMessage::init( const ModbusMessage& m )
 {
 	assert( m.pduhead.func == fnReadInputRegisters );
-//	memset(this, 0, sizeof(*this));
+	//	memset(this, 0, sizeof(*this));
 	memcpy(this, &m.pduhead, sizeof(m.pduhead));
-	memcpy(&start,m.data,szData());
+	memcpy(&start, m.data, szData());
 
 	// переворачиваем слова
 	start = SWAPSHORT(start);
@@ -1455,12 +1458,12 @@ void ForceCoilsMessage::init( const ModbusMessage& m )
 	memcpy(&crc, &(m.data[m.dlen - szCRC]), szCRC);
 }
 // -------------------------------------------------------------------------
-bool ForceCoilsMessage::checkFormat()
+bool ForceCoilsMessage::checkFormat() const
 {
 	return ( func == fnForceMultipleCoils );
 }
 // -------------------------------------------------------------------------
-size_t ForceCoilsMessage::szData()
+size_t ForceCoilsMessage::szData() const
 {
 	return szHead() + bcnt + szCRC;
 }
@@ -1511,7 +1514,7 @@ void ForceCoilsRetMessage::init( const ModbusMessage& m )
 {
 	assert( m.pduhead.func == fnForceMultipleCoils );
 
-//	memset(this, 0, sizeof(*this));
+	//	memset(this, 0, sizeof(*this));
 
 	// copy not include CRC
 	memcpy(this, &m.pduhead, szModbusHeader + m.dlen);
@@ -1703,13 +1706,13 @@ void WriteOutputMessage::init( const ModbusMessage& m )
 		data[i] = SWAPSHORT(data[i]);
 }
 // -------------------------------------------------------------------------
-bool WriteOutputMessage::checkFormat()
+bool WriteOutputMessage::checkFormat() const
 {
 	// return ( quant*sizeof(ModbusData) == bcnt ) && ( func == fnWriteOutputRegisters );
 	return ( (bcnt == (quant * sizeof(ModbusData))) && (func == fnWriteOutputRegisters) );
 }
 // -------------------------------------------------------------------------
-size_t WriteOutputMessage::szData()
+size_t WriteOutputMessage::szData() const
 {
 	return szHead() + bcnt + szCRC;
 }
@@ -1877,7 +1880,7 @@ ForceSingleCoilMessage& ForceSingleCoilMessage::operator=( const ModbusMessage&
 void ForceSingleCoilMessage::init( const ModbusMessage& m )
 {
 	assert( m.pduhead.func == fnForceSingleCoil );
-//	memset(this, 0, sizeof(*this));
+	//	memset(this, 0, sizeof(*this));
 
 	// копируем данные вместе с CRC
 	memcpy(this, &m.pduhead, szModbusHeader + m.dlen + szCRC);
@@ -1899,12 +1902,12 @@ void ForceSingleCoilMessage::init( const ModbusMessage& m )
 }
 
 // -------------------------------------------------------------------------
-bool ForceSingleCoilMessage::checkFormat()
+bool ForceSingleCoilMessage::checkFormat() const
 {
 	return (func == fnForceSingleCoil);
 }
 // -------------------------------------------------------------------------
-size_t ForceSingleCoilMessage::szData()
+size_t ForceSingleCoilMessage::szData() const
 {
 	return szHead() + sizeof(ModbusData) + szCRC;
 }
@@ -2048,7 +2051,7 @@ WriteSingleOutputMessage& WriteSingleOutputMessage::operator=( const ModbusMessa
 void WriteSingleOutputMessage::init( const ModbusMessage& m )
 {
 	assert( m.pduhead.func == fnWriteOutputSingleRegister );
-//	memset(this, 0, sizeof(*this));
+	//	memset(this, 0, sizeof(*this));
 
 	// копируем данные вместе с CRC
 	memcpy(this, &m.pduhead, szModbusHeader + m.dlen + szCRC);
@@ -2076,7 +2079,7 @@ bool WriteSingleOutputMessage::checkFormat()
 	return ( (func == fnWriteOutputSingleRegister) );
 }
 // -------------------------------------------------------------------------
-size_t WriteSingleOutputMessage::szData()
+size_t WriteSingleOutputMessage::szData() const
 {
 	return szHead() + sizeof(ModbusData) + szCRC;
 }
@@ -2120,7 +2123,7 @@ WriteSingleOutputRetMessage& WriteSingleOutputRetMessage::operator=( const Modbu
 // -------------------------------------------------------------------------
 void WriteSingleOutputRetMessage::init( const ModbusMessage& m )
 {
-//	memset(this, 0, sizeof(*this));
+	//	memset(this, 0, sizeof(*this));
 
 	// copy not include CRC
 	memcpy(this, &m.pduhead, szModbusHeader + m.dlen);
@@ -2365,7 +2368,7 @@ ModbusMessage DiagnosticMessage::transport_msg()
 	return std::move(mm);
 }
 // -------------------------------------------------------------------------
-size_t DiagnosticMessage::szData()
+size_t DiagnosticMessage::szData() const
 {
 	// фактическое число данных + контрольная сумма
 	return sizeof(subf) + count * sizeof(ModbusData) + szCRC;
@@ -2496,7 +2499,7 @@ void MEIMessageRDI::init( const ModbusMessage& m )
 	memcpy(&crc, &(m.data[m.dlen - szCRC]), szCRC);
 }
 // -------------------------------------------------------------------------
-bool MEIMessageRDI::checkFormat()
+bool MEIMessageRDI::checkFormat() const
 {
 	return ( type == 0x0E );
 }
@@ -2696,7 +2699,7 @@ ModbusMessage MEIMessageRetRDI::transport_msg()
 	return std::move(mm);
 }
 // -------------------------------------------------------------------------
-size_t MEIMessageRetRDI::szData()
+size_t MEIMessageRetRDI::szData() const
 {
 	// заголовочные поля + фактическое число данных + контрольная сумма
 	return 6 + bcnt + szCRC;
@@ -2761,7 +2764,7 @@ JournalCommandMessage::JournalCommandMessage( const ModbusMessage& m )
 JournalCommandMessage& JournalCommandMessage::operator=( const ModbusMessage& m )
 {
 	assert( m.pduhead.func == fnJournalCommand );
-//	memset(this, 0, sizeof(*this));
+	//	memset(this, 0, sizeof(*this));
 	memcpy(this, &m.pduhead, sizeof(*this)); // m.len
 
 	// переворачиваем слова
@@ -2867,7 +2870,7 @@ ModbusMessage JournalCommandRetMessage::transport_msg()
 	return std::move(mm);
 }
 // -------------------------------------------------------------------------
-size_t JournalCommandRetMessage::szData()
+size_t JournalCommandRetMessage::szData() const
 {
 	// фактическое число данных + контрольная сумма
 	return sizeof(bcnt) + count * sizeof(ModbusData) + szCRC;
@@ -3052,7 +3055,7 @@ std::ostream& ModbusRTU::operator<<(std::ostream& os, SetDateTimeMessage* m )
 	return os << (*m);
 }
 // -------------------------------------------------------------------------
-bool SetDateTimeMessage::checkFormat()
+bool SetDateTimeMessage::checkFormat() const
 {
 	/*
 	    // Lav: проверка >=0 бессмысленна, потому что в типе данных Modbusbyte не могут храниться отрицательные числа
@@ -3207,7 +3210,7 @@ void RemoteServiceMessage::init( const ModbusMessage& m )
 	memcpy(&crc, &(m.data[m.dlen - szCRC]), szCRC);
 }
 // -------------------------------------------------------------------------
-size_t RemoteServiceMessage::szData()
+size_t RemoteServiceMessage::szData() const
 {
 	return szHead() + bcnt + szCRC;
 }
@@ -3264,7 +3267,7 @@ void RemoteServiceRetMessage::clear()
 	bcnt    = 0;
 }
 // -------------------------------------------------------------------------
-size_t RemoteServiceRetMessage::szData()
+size_t RemoteServiceRetMessage::szData() const
 {
 	// фактическое число данных + контрольная сумма
 	return sizeof(bcnt) + count * sizeof(ModbusByte) + szCRC;
@@ -3314,7 +3317,7 @@ ReadFileRecordMessage& ReadFileRecordMessage::operator=( const ModbusMessage& m
 	return *this;
 }
 // -------------------------------------------------------------------------
-bool ReadFileRecordMessage::checkFormat()
+bool ReadFileRecordMessage::checkFormat() const
 {
 	return ( bcnt >= 0x07 && bcnt <= 0xF5 );
 }
@@ -3352,7 +3355,7 @@ void ReadFileRecordMessage::init( const ModbusMessage& m )
 	}
 }
 // -------------------------------------------------------------------------
-size_t ReadFileRecordMessage::szData()
+size_t ReadFileRecordMessage::szData() const
 {
 	// фактическое число данных + контрольная сумма
 	return sizeof(bcnt) + count * sizeof(SubRequest) + szCRC;
@@ -3520,7 +3523,7 @@ size_t FileTransferRetMessage::getDataLen( const ModbusMessage& m )
 	return (size_t)m.data[0];
 }
 // -----------------------------------------------------------------------
-size_t FileTransferRetMessage::szData()
+size_t FileTransferRetMessage::szData() const
 {
 	// фактическое число данных + контрольная сумма
 	return sizeof(ModbusByte) * 2 + sizeof(ModbusData) * 3 + dlen + szCRC;

src/Log/LogServer.cc

@@ -196,6 +196,7 @@ void LogServer::ioAccept( ev::io& watcher, int revents )
 		{
 			uniset_rwmutex_wrlock l(mutSList);
 			scount++;
+
 			// на первой сессии запоминаем состояние логов
 			if( scount == 1 )
 				saveDefaultLogLevels("ALL");
@@ -258,7 +259,8 @@ string LogServer::getShortInfo()
 	inf << "LogServer: " << myname << endl;
 	{
 		uniset_rwmutex_wrlock l(mutSList);
-		for( const auto& s: slist )
+
+		for( const auto& s : slist )
 			inf << " " << s->getShortInfo() << endl;
 	}
 
@@ -271,15 +273,17 @@ void LogServer::saveDefaultLogLevels( const std::string& logname )
 		mylog.info() << myname << "(saveDefaultLogLevels): SAVE DEFAULT LOG LEVELS.." << endl;
 
 	auto alog = dynamic_pointer_cast<LogAgregator>(elog);
+
 	if( alog )
 	{
 		std::list<LogAgregator::iLog> lst;
+
 		if( logname.empty() || logname == "ALL" )
 			lst = alog->getLogList();
 		else
 			lst = alog->getLogList(logname);
 
-		for( auto&& l: lst )
+		for( auto && l : lst )
 			defaultLogLevels[l.log.get()] = l.log->level();
 	}
 	else if( elog )
@@ -292,17 +296,20 @@ void LogServer::restoreDefaultLogLevels( const std::string& logname )
 		mylog.info() << myname << "(restoreDefaultLogLevels): RESTORE DEFAULT LOG LEVELS.." << endl;
 
 	auto alog = dynamic_pointer_cast<LogAgregator>(elog);
+
 	if( alog )
 	{
 		std::list<LogAgregator::iLog> lst;
+
 		if( logname.empty() || logname == "ALL" )
 			lst = alog->getLogList();
 		else
 			lst = alog->getLogList(logname);
 
-		for( auto&& l: lst )
+		for( auto && l : lst )
 		{
 			auto d = defaultLogLevels.find(l.log.get());
+
 			if( d != defaultLogLevels.end() )
 				l.log->level(d->second);
 		}
@@ -310,6 +317,7 @@ void LogServer::restoreDefaultLogLevels( const std::string& logname )
 	else if( elog )
 	{
 		auto d = defaultLogLevels.find(elog.get());
+
 		if( d != defaultLogLevels.end() )
 			elog->level(d->second);
 	}
@@ -331,9 +339,11 @@ std::string LogServer::onCommand( LogSession* s, LogServerTypes::Command cmd, co
 		s << "List of saved default log levels (filter='" << logname << "')[" << defaultLogLevels.size() << "]: " << endl;
 		s << "=================================" << endl;
 		auto alog = dynamic_pointer_cast<LogAgregator>(elog);
+
 		if( alog ) // если у нас "агрегатор", то работаем с его списком потоков
 		{
 			std::list<LogAgregator::iLog> lst;
+
 			if( logname.empty() || logname == "ALL" )
 				lst = alog->getLogList();
 			else
@@ -349,6 +359,7 @@ std::string LogServer::onCommand( LogSession* s, LogServerTypes::Command cmd, co
 			{
 				Debug::type deflevel = Debug::NONE;
 				auto i = defaultLogLevels.find(l.log.get());
+
 				if( i != defaultLogLevels.end() )
 					deflevel = i->second;
 
@@ -359,8 +370,10 @@ std::string LogServer::onCommand( LogSession* s, LogServerTypes::Command cmd, co
 		{
 			Debug::type deflevel = Debug::NONE;
 			auto i = defaultLogLevels.find(elog.get());
+
 			if( i != defaultLogLevels.end() )
 				deflevel = i->second;
+
 			s << elog->getLogName() << " [" << Debug::str(deflevel) << " ]" << endl;
 		}
 

src/Log/LogSession.cc

@@ -54,7 +54,7 @@ LogSession::~LogSession()
 // -------------------------------------------------------------------------
 LogSession::LogSession( int sfd, std::shared_ptr<DebugStream>& _log, timeout_t _cmdTimeout, timeout_t _checkConnectionTime ):
 	cmdTimeout(_cmdTimeout),
-	checkConnectionTime(_checkConnectionTime/1000.),
+	checkConnectionTime(_checkConnectionTime / 1000.),
 	peername(""),
 	caddr(""),
 	log(_log)
@@ -103,24 +103,28 @@ void LogSession::logOnEvent( const std::string& s )
 	if( cancelled || s.empty() )
 		return;
 
-	{ // чтобы поменьше удерживать mutex
+	{
+		// чтобы поменьше удерживать mutex
 		std::unique_lock<std::mutex> lk(logbuf_mutex);
 
 		// собираем статистику..
 		// --------------------------
-		if( s.size() < minSizeMsg || minSizeMsg==0 )
+		if( s.size() < minSizeMsg || minSizeMsg == 0 )
 			minSizeMsg = s.size();
+
 		if( s.size() > maxSizeMsg )
 			maxSizeMsg = s.size();
 
 		if( logbuf.size() > maxCount )
 			maxCount = logbuf.size();
+
 		// --------------------------
 
 		// проверяем на переполнение..
 		if( logbuf.size() >= maxRecordsNum )
 		{
 			numLostMsg++;
+
 			if( !lostMsg )
 			{
 				ostringstream err;
@@ -173,6 +177,7 @@ void LogSession::terminate()
 
 	{
 		std::unique_lock<std::mutex> lk(logbuf_mutex);
+
 		while( !logbuf.empty() )
 			logbuf.pop();
 	}
@@ -282,6 +287,7 @@ void LogSession::writeEvent( ev::io& watcher )
 
 	{
 		std::unique_lock<std::mutex> lk(logbuf_mutex);
+
 		if( logbuf.empty() )
 		{
 			io.set(EV_NONE);
@@ -451,7 +457,7 @@ void LogSession::cmdProcessing( const string& cmdLogName, const LogServerTypes::
 			case LogServerTypes::cmdSaveLogLevel:
 			case LogServerTypes::cmdRestoreLogLevel:
 			case LogServerTypes::cmdViewDefaultLogLevel:
-			break;
+				break;
 
 			default:
 				mylog.warn() << peername << "(run): Unknown command '" << msg.cmd << "'" << endl;
@@ -479,7 +485,8 @@ void LogSession::cmdProcessing( const string& cmdLogName, const LogServerTypes::
 
 	try
 	{
-		std::string ret( std::move(m_command_sig.emit(this,msg.cmd,cmdLogName)) );
+		std::string ret( std::move(m_command_sig.emit(this, msg.cmd, cmdLogName)) );
+
 		if( !ret.empty() )
 		{
 			{
@@ -522,6 +529,7 @@ void LogSession::onCheckConnectionTimer( ev::timer& watcher, int revents )
 	}
 
 	std::unique_lock<std::mutex> lk(logbuf_mutex);
+
 	if( !logbuf.empty() )
 	{
 		checkConnectionTimer.start( checkConnectionTime ); // restart timer
@@ -551,13 +559,23 @@ LogSession::LogSessionCommand_Signal LogSession::signal_logsession_command()
 	return m_command_sig;
 }
 // ---------------------------------------------------------------------
+void LogSession::cancel()
+{
+	cancelled = true;
+}
+// ---------------------------------------------------------------------
 void LogSession::setMaxBufSize( size_t num )
 {
 	std::unique_lock<std::mutex> lk(logbuf_mutex);
 	maxRecordsNum = num;
 }
 // ---------------------------------------------------------------------
-bool LogSession::isAcive()
+size_t LogSession::getMaxBufSize() const
+{
+	return maxRecordsNum;
+}
+// ---------------------------------------------------------------------
+bool LogSession::isAcive() const
 {
 	return io.is_active();
 }

src/ObjectRepository/ObjectIndex.cc

@@ -29,7 +29,7 @@ using namespace UniSetTypes;
 //const std::string ObjectIndex::sepNode = ":";
 // -----------------------------------------------------------------------------------------
 
-string ObjectIndex::getNameById( const ObjectId id )
+string ObjectIndex::getNameById( const ObjectId id ) const
 {
 	return getMapName(id);
 }

src/ObjectRepository/ObjectIndex_Array.cc

@@ -47,7 +47,7 @@ ObjectIndex_Array::ObjectIndex_Array( const ObjectInfo* objectInfo ):
 	}
 }
 // -----------------------------------------------------------------------------------------
-ObjectId ObjectIndex_Array::getIdByName( const string& name )
+ObjectId ObjectIndex_Array::getIdByName( const string& name ) const
 {
 	auto it = mok.find(name);
 
@@ -58,7 +58,7 @@ ObjectId ObjectIndex_Array::getIdByName( const string& name )
 }
 
 // -----------------------------------------------------------------------------------------
-string ObjectIndex_Array::getMapName( const ObjectId id )
+string ObjectIndex_Array::getMapName( const ObjectId id ) const
 {
 	if( id != UniSetTypes::DefaultObjectId && id >= 0 && id < maxId )
 		return objectInfo[id].repName;
@@ -67,7 +67,7 @@ string ObjectIndex_Array::getMapName( const ObjectId id )
 	//    throw OutOfRange("ObjectIndex_Array::getMapName OutOfRange");
 }
 // -----------------------------------------------------------------------------------------
-string ObjectIndex_Array::getTextName( const ObjectId id )
+string ObjectIndex_Array::getTextName( const ObjectId id ) const
 {
 	if( id != UniSetTypes::DefaultObjectId && id >= 0 && id < maxId )
 		return objectInfo[id].textName;
@@ -82,7 +82,7 @@ std::ostream& operator<<(std::ostream& os, ObjectIndex_Array& oi )
 }
 // -----------------------------------------------------------------------------------------
 
-std::ostream& ObjectIndex_Array::printMap( std::ostream& os )
+std::ostream& ObjectIndex_Array::printMap( std::ostream& os ) const
 {
 	auto oind = uniset_conf()->oind;
 
@@ -101,7 +101,7 @@ std::ostream& ObjectIndex_Array::printMap( std::ostream& os )
 	return os;
 }
 // -----------------------------------------------------------------------------------------
-const ObjectInfo* ObjectIndex_Array::getObjectInfo( const ObjectId id )
+const ObjectInfo* ObjectIndex_Array::getObjectInfo( const ObjectId id ) const
 {
 	if( id != UniSetTypes::DefaultObjectId && id >= 0 && id < maxId )
 		return &(objectInfo[id]);
@@ -109,7 +109,7 @@ const ObjectInfo* ObjectIndex_Array::getObjectInfo( const ObjectId id )
 	return NULL;
 }
 // -----------------------------------------------------------------------------------------
-const ObjectInfo* ObjectIndex_Array::getObjectInfo( const std::string& name )
+const ObjectInfo* ObjectIndex_Array::getObjectInfo( const std::string& name ) const
 {
 	auto it = mok.find(name);
 

src/ObjectRepository/ObjectIndex_XML.cc

@@ -24,7 +24,7 @@
 using namespace UniSetTypes;
 using namespace std;
 // -----------------------------------------------------------------------------------------
-ObjectIndex_XML::ObjectIndex_XML( const string& xmlfile, int minSize ):
+ObjectIndex_XML::ObjectIndex_XML(const string& xmlfile, size_t minSize ):
 	omap(minSize)
 {
 	shared_ptr<UniXML> xml = make_shared<UniXML>();
@@ -36,7 +36,7 @@ ObjectIndex_XML::ObjectIndex_XML( const string& xmlfile, int minSize ):
 	//    catch(...){}
 }
 // -----------------------------------------------------------------------------------------
-ObjectIndex_XML::ObjectIndex_XML( const std::shared_ptr<UniXML>& xml, int minSize ):
+ObjectIndex_XML::ObjectIndex_XML(const std::shared_ptr<UniXML>& xml, size_t minSize ):
 	omap(minSize)
 {
 	build(xml);
@@ -46,7 +46,7 @@ ObjectIndex_XML::~ObjectIndex_XML()
 {
 }
 // -----------------------------------------------------------------------------------------
-ObjectId ObjectIndex_XML::getIdByName( const string& name )
+ObjectId ObjectIndex_XML::getIdByName( const string& name ) const
 {
 	auto it = mok.find(name);
 
@@ -56,7 +56,7 @@ ObjectId ObjectIndex_XML::getIdByName( const string& name )
 	return DefaultObjectId;
 }
 // -----------------------------------------------------------------------------------------
-string ObjectIndex_XML::getMapName( const ObjectId id )
+string ObjectIndex_XML::getMapName( const ObjectId id ) const
 {
 	if( (unsigned)id < omap.size() && (unsigned)id > 0 )
 		return omap[id].repName;
@@ -64,7 +64,7 @@ string ObjectIndex_XML::getMapName( const ObjectId id )
 	return "";
 }
 // -----------------------------------------------------------------------------------------
-string ObjectIndex_XML::getTextName( const ObjectId id )
+string ObjectIndex_XML::getTextName( const ObjectId id ) const
 {
 	if( (unsigned)id < omap.size() && (unsigned)id > 0 )
 		return omap[id].textName;
@@ -77,9 +77,9 @@ std::ostream& operator<<(std::ostream& os, ObjectIndex_XML& oi )
 	return oi.printMap(os);
 }
 // -----------------------------------------------------------------------------------------
-std::ostream& ObjectIndex_XML::printMap( std::ostream& os )
+std::ostream& ObjectIndex_XML::printMap( std::ostream& os ) const
 {
-	cout << "size: " << omap.size() << endl;
+	os << "size: " << omap.size() << endl;
 
 	for( auto it = omap.begin(); it != omap.end(); ++it )
 	{
@@ -272,7 +272,7 @@ unsigned int ObjectIndex_XML::read_nodes( const std::shared_ptr<UniXML>& xml, co
 	return ind;
 }
 // ------------------------------------------------------------------------------------------
-const ObjectInfo* ObjectIndex_XML::getObjectInfo( const ObjectId id )
+const ObjectInfo* ObjectIndex_XML::getObjectInfo( const ObjectId id ) const
 {
 	if( (unsigned)id < omap.size() && (unsigned)id > 0 )
 		return &omap[id];
@@ -280,7 +280,7 @@ const ObjectInfo* ObjectIndex_XML::getObjectInfo( const ObjectId id )
 	return NULL;
 }
 // ------------------------------------------------------------------------------------------
-const ObjectInfo* ObjectIndex_XML::getObjectInfo( const std::string& name )
+const ObjectInfo* ObjectIndex_XML::getObjectInfo( const std::string& name ) const
 {
 	auto it = mok.find(name);
 

src/ObjectRepository/ObjectIndex_idXML.cc

@@ -43,7 +43,7 @@ ObjectIndex_idXML::~ObjectIndex_idXML()
 {
 }
 // -----------------------------------------------------------------------------------------
-ObjectId ObjectIndex_idXML::getIdByName( const string& name )
+ObjectId ObjectIndex_idXML::getIdByName( const string& name ) const
 {
 	auto it = mok.find(name);
 
@@ -53,7 +53,7 @@ ObjectId ObjectIndex_idXML::getIdByName( const string& name )
 	return DefaultObjectId;
 }
 // -----------------------------------------------------------------------------------------
-string ObjectIndex_idXML::getMapName( const ObjectId id )
+string ObjectIndex_idXML::getMapName( const ObjectId id ) const
 {
 	auto it = omap.find(id);
 
@@ -63,7 +63,7 @@ string ObjectIndex_idXML::getMapName( const ObjectId id )
 	return "";
 }
 // -----------------------------------------------------------------------------------------
-string ObjectIndex_idXML::getTextName( const ObjectId id )
+string ObjectIndex_idXML::getTextName( const ObjectId id ) const
 {
 	auto it = omap.find(id);
 
@@ -78,7 +78,7 @@ std::ostream& operator<<(std::ostream& os, ObjectIndex_idXML& oi )
 	return oi.printMap(os);
 }
 // -----------------------------------------------------------------------------------------
-std::ostream& ObjectIndex_idXML::printMap( std::ostream& os )
+std::ostream& ObjectIndex_idXML::printMap( std::ostream& os ) const
 {
 	os << "size: " << omap.size() << endl;
 
@@ -235,7 +235,7 @@ void ObjectIndex_idXML::read_nodes( const std::shared_ptr<UniXML>& xml, const st
 	}
 }
 // ------------------------------------------------------------------------------------------
-const ObjectInfo* ObjectIndex_idXML::getObjectInfo( const ObjectId id )
+const ObjectInfo* ObjectIndex_idXML::getObjectInfo( const ObjectId id ) const
 {
 	auto it = omap.find(id);
 
@@ -245,7 +245,7 @@ const ObjectInfo* ObjectIndex_idXML::getObjectInfo( const ObjectId id )
 	return NULL;
 }
 // ------------------------------------------------------------------------------------------
-const ObjectInfo* ObjectIndex_idXML::getObjectInfo( const std::string& name )
+const ObjectInfo* ObjectIndex_idXML::getObjectInfo( const std::string& name ) const
 {
 	auto it = mok.find(name);
 

src/ObjectRepository/UniSetActivator.cc

@@ -22,6 +22,7 @@
 #include <sys/types.h>
 #include <signal.h>
 #include <sstream>
+#include <fstream>
 
 #include <condition_variable>
 #include <thread>
@@ -33,6 +34,7 @@
 // --------------------
 #include <execinfo.h>
 #include <cxxabi.h>
+#include <dlfcn.h>
 #include <iomanip>
 // --------------------
 
@@ -96,6 +98,7 @@ static std::atomic_bool g_term = ATOMIC_VAR_INIT(0);
 static std::atomic_bool g_done = ATOMIC_VAR_INIT(0);
 static std::atomic_bool g_work_stopped = ATOMIC_VAR_INIT(0);
 static std::atomic_int g_signo = ATOMIC_VAR_INIT(0);
+static std::atomic_bool g_trace_done = ATOMIC_VAR_INIT(0);
 
 static std::mutex              g_workmutex;
 static std::mutex              g_termmutex;
@@ -104,12 +107,15 @@ static std::mutex              g_finimutex;
 static std::condition_variable g_finievent;
 static std::mutex              g_donemutex;
 static std::condition_variable g_doneevent;
+static std::mutex              g_trace_donemutex;
+static std::condition_variable g_trace_doneevent;
 static std::shared_ptr<std::thread> g_term_thread;
 static std::shared_ptr<std::thread> g_fini_thread;
 static std::shared_ptr<std::thread> g_kill_thread;
-static const int TERMINATE_TIMEOUT = 3; //  время отведенное на завершение процесса [сек]
+static const int TERMINATE_TIMEOUT_SEC = 3; //  время отведенное на завершение процесса [сек]
 static const int THREAD_TERMINATE_PAUSE = 500; // [мсек] пауза при завершении потока (см. work())
-static const int KILL_TIMEOUT = 8;
+static const int KILL_TIMEOUT_SEC = 8;
+static pid_t g_stacktrace_proc_pid = 0; // pid процесса делающего stack trace (для защиты от зависания)
 // ------------------------------------------------------------------------------------------
 // Чтобы не выделять память во время "вылета",
 // выделим необходимое для stacktrace зараннее
@@ -117,8 +123,11 @@ static const int KILL_TIMEOUT = 8;
 #define FUNCNAMESIZE 256
 #define MAXFRAMES 64
 // выделение специального стека заранее
-static char g_stack_body[MAXFRAMES*FUNCNAMESIZE+500];
+// +60 - это на всякие переменные при обработке stack trace и т.п.
+static char g_stack_body[(MAXFRAMES + 60)*FUNCNAMESIZE];
+static char trace_buf[10000];
 static stack_t g_sigseg_stack;
+static void on_stacktrace_timeout(); // поток для защиты от зависания "процесса создания stack trace"
 // ------------------------------------------------------------------------------------------
 // код функции printStackTrace взят с https://oroboro.com/stack-trace-on-crash/
 // будет работать только под LINUX (т.к. используется backtrace)
@@ -158,70 +167,37 @@ static inline void printStackTrace()
 
 	TRACELOG << std::left;
 
-	size_t funcnamesize = FUNCNAMESIZE;
-	char funcname[FUNCNAMESIZE];
-
 	// iterate over the returned symbol lines. skip the first, it is the
 	// address of this function.
 	for ( unsigned int i = 4; i < addrlen; i++ )
 	{
-		char* begin_name   = NULL;
-		char* begin_offset = NULL;
-		char* end_offset   = NULL;
-
-		// find parentheses and +address offset surrounding the mangled name
-		for ( char* p = symbollist[i]; *p; ++p )
-		{
-			if ( *p == '(' )
-				begin_name = p;
-			else if ( *p == '+' )
-				begin_offset = p;
-			else if ( *p == ')' && ( begin_offset || begin_name ))
-				end_offset = p;
-		}
-
-		if ( begin_name && end_offset && ( begin_name < end_offset ))
-		{
-			*begin_name++   = '\0';
-			*end_offset++   = '\0';
+		Dl_info dl;
 
-			if ( begin_offset )
-				*begin_offset++ = '\0';
+		if(!dladdr(addrlist[i], &dl))
+			break;
 
-			// mangled name is now in [begin_name, begin_offset) and caller
-			// offset in [begin_offset, end_offset). now apply
-			// __cxa_demangle():
+		const char* sym = dl.dli_sname;
 
-			int status = 0;
-			char* ret = abi::__cxa_demangle( begin_name, funcname,
-											 &funcnamesize, &status );
-			char* fname = begin_name;
+		int status = 0;
+		char* ret = abi::__cxa_demangle( sym, NULL, 0, &status );
 
-			if ( status == 0 )
-				fname = ret;
+		if( status == 0 && ret )
+			sym = ret;
 
-			if ( begin_offset )
-			{
-				TRACELOG << setw(30) << symbollist[i]
-						   << " ( " << setw(40) << fname
-						   << " +" << setw(6) << begin_offset
-						   << ") " << end_offset
-						   << endl;
-			}
-			else
-			{
-				TRACELOG << setw(30) << symbollist[i]
-						   << " ( " << setw(40) << fname
-						   << " " << setw(6) << ""
-						   << ") " << end_offset
-						   << endl;
-			}
+		if( dl.dli_fname && sym )
+		{
+			TRACELOG << setw(30) << symbollist[i]
+					 << " ( " << setw(40) << dl.dli_fname
+					 << " ):  " << sym
+					 << endl << flush;
 		}
 		else
 		{
-			// couldn't parse the line? print the whole line.
-			TRACELOG << setw(40) << symbollist[i] << endl;
+			TRACELOG << setw(30) << symbollist[i] << endl << flush;
 		}
+
+		if( ret )
+			std::free(ret);
 	}
 
 	std::free(symbollist);
@@ -239,15 +215,9 @@ bool gdb_print_trace()
 	char pid_buf[30];
 	sprintf(pid_buf, "%d", getpid());
 	char name_buf[512];
-	name_buf[readlink("/proc/self/exe", name_buf, 511)]=0;
+	name_buf[readlink("/proc/self/exe", name_buf, 511)] = 0;
 
-	// Чтобы перенаправить вывод в свой log, делаем pipe
-	int cp[2]; /* Child to parent pipe */
-	if( pipe(cp) < 0)
-	{
-		perror("Can't make pipe");
-		return false;
-	}
+	TRACELOG << "stack trace: for " << name_buf << " pid=" << pid_buf << endl;
 
 	int child_pid = fork();
 
@@ -257,18 +227,13 @@ bool gdb_print_trace()
 		return false;
 	}
 
-	if (!child_pid) {
-
-		close(cp[0]);
-		close( fileno(stdout) );
-		dup2(cp[1], fileno(stdout));
-		close( fileno(stderr) );
-		dup2(fileno(stdout), fileno(stderr));
-		TRACELOG << "stack trace for " << name_buf << " pid=" << pid_buf << endl;
+	if( child_pid == 0 ) // CHILD
+	{
+		msleep(300); // пауза чтобы родитель успел подготовиться..
+		dup2(2, 1); // redirect output to stderr
 
 		if( g_act && !g_act->getAbortScript().empty() )
 		{
-			TRACELOG << "run abort script " << g_act->getAbortScript() << endl;
 			execlp(g_act->getAbortScript().c_str(), g_act->getAbortScript().c_str(), name_buf, pid_buf, NULL);
 		}
 		else
@@ -278,34 +243,50 @@ bool gdb_print_trace()
 			execlp("gdb", "gdb", "--batch", "-n", "-ex", "thread apply all bt", name_buf, pid_buf, NULL);
 		}
 
-		//abort(); /* If gdb failed to start */
+		// abort(); /* If gdb failed to start */
 		return false;
 	}
-	else
+	else // PARENT
 	{
-		close(cp[1]);
-		char buf[5000];
-		while( true )
+		if( g_act && !g_act->getAbortScript().empty() )
 		{
-			ssize_t r = ::read(cp[0], &buf, sizeof(buf) - 1 );
+			TRACELOG << "stack trace: run script " << g_act->getAbortScript() << endl;
+		}
 
-			if( r > 0 )
-			{
-				buf[r] = '\0';
-				TRACELOG << buf;
-				continue;
-			}
+		g_stacktrace_proc_pid = child_pid;
+		g_trace_done = false;
+		std::thread t(on_stacktrace_timeout); // запускаем поток "защищающий" от зависания процесса создания stack trace
 
-			break;
-		}
+		waitpid(child_pid, NULL, 0);
 
-		waitpid(child_pid,NULL,0);
+		g_trace_done = true;
+		g_trace_doneevent.notify_all();
+		t.join();
 	}
 
 	TRACELOG << "-----------------------------------------" << endl << flush;
 	return true;
 }
 // ------------------------------------------------------------------------------------------
+static void on_stacktrace_timeout()
+{
+	ulogsys << "****** STACK TRACE guard thread start (for pid=" << g_stacktrace_proc_pid << ") ******" << endl << flush;
+	std::unique_lock<std::mutex> lk(g_trace_donemutex);
+
+	g_trace_doneevent.wait_for(lk, std::chrono::milliseconds(KILL_TIMEOUT_SEC * 1000), []()
+	{
+		return (g_trace_done == true);
+	} );
+
+	if( !g_trace_done )
+	{
+		ulogsys << "****** STACK TRACE TIMEOUT.. (kill process) *******" << endl << flush;
+		kill(g_stacktrace_proc_pid, SIGKILL);
+	}
+	else
+		ulogsys << "****** STACK TRACE guard thread finish ******" << endl << flush;
+}
+// ------------------------------------------------------------------------------------------
 static void activator_terminate( int signo )
 {
 	if( g_term )
@@ -357,21 +338,21 @@ void finished_thread()
 	g_finished = true;
 
 	std::unique_lock<std::mutex> lkw(g_workmutex);
-	g_finievent.wait_for(lkw, std::chrono::milliseconds(TERMINATE_TIMEOUT * 1000), []()
+	g_finievent.wait_for(lkw, std::chrono::milliseconds(TERMINATE_TIMEOUT_SEC * 1000), []()
 	{
 		return (g_work_stopped == true);
 	} );
 	ulogsys << "****** FINISHED END ****" << endl << flush;
 }
 // ------------------------------------------------------------------------------------------
-void kill_thread()
+void on_finish_timeout()
 {
 	std::unique_lock<std::mutex> lk(g_donemutex);
 
 	if( g_done )
 		return;
 
-	g_doneevent.wait_for(lk, std::chrono::milliseconds(KILL_TIMEOUT * 1000), []()
+	g_doneevent.wait_for(lk, std::chrono::milliseconds(KILL_TIMEOUT_SEC * 1000), []()
 	{
 		return (g_done == true);
 	} );
@@ -411,7 +392,7 @@ void terminate_thread()
 	{
 		std::unique_lock<std::mutex> lk(g_donemutex);
 		g_done = false;
-		g_kill_thread = make_shared<std::thread>(kill_thread);
+		g_kill_thread = make_shared<std::thread>(on_finish_timeout);
 	}
 
 	if( g_act )
@@ -542,7 +523,7 @@ void UniSetActivator::init()
 
 	_noUseGdbForStackTrace = ( findArgParam("--uniset-no-use-gdb-for-stacktrace", conf->getArgc(), conf->getArgv()) != -1 );
 
-	abortScript = conf->getArgParam("--uniset-abort-script","");
+	abortScript = conf->getArgParam("--uniset-abort-script", "");
 
 	orb = conf->getORB();
 	CORBA::Object_var obj = orb->resolve_initial_references("RootPOA");
@@ -717,11 +698,11 @@ void UniSetActivator::work()
 	try
 	{
 		if( orbthr )
-			thpid = orbthr->getTID();
+			thid = orbthr->getTID();
 		else
-			thpid = getpid();
+			thid = getpid();
 
-		g_term_thread = make_shared<std::thread>(terminate_thread );
+		g_term_thread = make_shared<std::thread>(terminate_thread);
 		omniORB::setMainThread();
 		orb->run();
 	}
@@ -819,14 +800,16 @@ void UniSetActivator::set_signals(bool ask)
 	sigemptyset(&act.sa_mask);
 	sigaddset(&act.sa_mask, SIGSEGV);
 	act.sa_flags = 0;
-	act.sa_flags |= SA_RESTART;
+	//	act.sa_flags |= SA_RESTART;
 	act.sa_flags |= SA_RESETHAND;
 
+#if 1
 	g_sigseg_stack.ss_sp = g_stack_body;
 	g_sigseg_stack.ss_flags = SS_ONSTACK;
 	g_sigseg_stack.ss_size = sizeof(g_stack_body);
 	assert(!sigaltstack(&g_sigseg_stack, nullptr));
 	act.sa_flags |= SA_ONSTACK;
+#endif
 
 	if(ask)
 		act.sa_handler = activator_terminate_with_calltrace;

src/ObjectRepository/UniSetObject.cc

@@ -130,6 +130,7 @@ void UniSetObject::initObject()
 	auto conf = uniset_conf();
 
 	int sz = conf->getArgPInt("--uniset-object-size-message-queue", conf->getField("SizeOfMessageQueue"), 1000);
+
 	if( sz > 0 )
 		setMaxSizeOfMessageQueue(sz);
 
@@ -187,6 +188,7 @@ VoidMessagePtr UniSetObject::receiveMessage()
 VoidMessagePtr UniSetObject::waitMessage( timeout_t timeMS )
 {
 	auto m = receiveMessage();
+
 	if( m )
 		return m;
 
@@ -323,6 +325,7 @@ void UniSetObject::setThreadPriority( int p )
 void UniSetObject::push( const TransportMessage& tm )
 {
 	auto vm = make_shared<VoidMessage>(tm);
+
 	if( vm->priority == Message::Medium )
 		mqueueMedium.push(vm);
 	else if( vm->priority == Message::High )
@@ -556,6 +559,7 @@ void UniSetObject::callback()
 	try
 	{
 		auto m = waitMessage(sleepTime);
+
 		if( m )
 			processingMessage(m.get());
 

src/Processes/EventLoopServer.cc

@@ -32,7 +32,7 @@ void EventLoopServer::evrun( bool thread )
 		thr = make_shared<std::thread>( [ = ] { defaultLoop(); } );
 }
 // ---------------------------------------------------------------------------
-bool EventLoopServer::evIsActive()
+bool EventLoopServer::evIsActive() const
 {
 	return isrunning;
 }

src/Various/LT_Object.cc

@@ -137,7 +137,7 @@ timeout_t LT_Object::getTimeInterval( TimerId timerid )
 	return 0;
 }
 // ------------------------------------------------------------------------------------------
-timeout_t LT_Object::getTimeLeft(TimerId timerid)
+timeout_t LT_Object::getTimeLeft( TimerId timerid )
 {
 	// lock
 	uniset_rwmutex_rlock lock(lstMutex);

src/Various/MQAtomic.cc

@@ -44,26 +44,28 @@ void MQAtomic::push( const VoidMessagePtr& vm )
 	if( wpos < rpos )
 	{
 		// только надо привести к одному масштабу
-		unsigned long w = wpos%SizeOfMessageQueue;
-		unsigned long r = rpos%SizeOfMessageQueue;
+		unsigned long w = wpos % SizeOfMessageQueue;
+		unsigned long r = rpos % SizeOfMessageQueue;
 
-		if( lostStrategy == lostNewData && (r-w) >= SizeOfMessageQueue )
+		if( lostStrategy == lostNewData && (r - w) >= SizeOfMessageQueue )
 		{
 			stCountOfLostMessages++;
 			return;
 		}
 	}
+
 	// -----------------------------------------------
 
 	// сперва надо сдвинуть счётчик (чтобы следующий поток уже писал в новое место)
 	unsigned long w = wpos.fetch_add(1);
 
 	// а потом уже добавлять новое сообщение в "зарезервированное" место
-	mqueue[w%SizeOfMessageQueue] = vm;
+	mqueue[w % SizeOfMessageQueue] = vm;
 	qpos.fetch_add(1); // теперь увеличиваем реальное количество элементов в очереди
 
 	// ведём статистику
 	size_t sz = qpos - rpos;
+
 	if( sz > stMaxQueueMessages )
 		stMaxQueueMessages = sz;
 }
@@ -90,7 +92,7 @@ VoidMessagePtr MQAtomic::top()
 	{
 		// сперва надо сдвинуть счётчик (чтобы следующий поток уже работал с следующим значением)
 		unsigned long r = rpos.fetch_add(1);
-		return mqueue[r%SizeOfMessageQueue];
+		return mqueue[r % SizeOfMessageQueue];
 	}
 
 	// Если rpos > qpos, значит qpos уже перешёл через максимум
@@ -98,8 +100,8 @@ VoidMessagePtr MQAtomic::top()
 	if( rpos > qpos ) // делаем if каждый раз, т.к. qpos может уже поменяться в параллельном потоке
 	{
 		// приводим к одному масштабу
-		unsigned long w = qpos%SizeOfMessageQueue;
-		unsigned long r = rpos%SizeOfMessageQueue;
+		unsigned long w = qpos % SizeOfMessageQueue;
+		unsigned long r = rpos % SizeOfMessageQueue;
 
 		if( lostStrategy == lostOldData && (r - w) >= SizeOfMessageQueue )
 		{
@@ -109,13 +111,13 @@ VoidMessagePtr MQAtomic::top()
 
 		// продолжаем читать как обычно
 		r = rpos.fetch_add(1);
-		return mqueue[r%SizeOfMessageQueue];
+		return mqueue[r % SizeOfMessageQueue];
 	}
 
 	return nullptr;
 }
 //---------------------------------------------------------------------------
-size_t MQAtomic::size()
+size_t MQAtomic::size() const
 {
 	// т.к. rpos корректируется только при фактическом вызое top()
 	// то тут приходиться смотреть если у нас переполнение
@@ -127,7 +129,7 @@ size_t MQAtomic::size()
 	return (qpos - rpos);
 }
 //---------------------------------------------------------------------------
-bool MQAtomic::empty()
+bool MQAtomic::empty() const
 {
 	return (qpos == rpos);
 }
@@ -141,7 +143,7 @@ void MQAtomic::setMaxSizeOfMessageQueue( size_t s )
 	}
 }
 //---------------------------------------------------------------------------
-size_t MQAtomic::getMaxSizeOfMessageQueue()
+size_t MQAtomic::getMaxSizeOfMessageQueue() const
 {
 	return SizeOfMessageQueue;
 }
@@ -155,7 +157,8 @@ void MQAtomic::mqFill( const VoidMessagePtr& v )
 {
 	mqueue.reserve(SizeOfMessageQueue);
 	mqueue.clear();
-	for( size_t i=0; i<SizeOfMessageQueue; i++ )
+
+	for( size_t i = 0; i < SizeOfMessageQueue; i++ )
 		mqueue.push_back(v);
 }
 //---------------------------------------------------------------------------

src/Various/MQMutex.cc

@@ -36,9 +36,10 @@ void MQMutex::push( const VoidMessagePtr& vm )
 	// проверяем переполнение, только если стратегия "терять новые данные"
 	// иначе нет смысла проверять, а можно просто писать новые данные затирая старые
 	// (sz+1) - т.к мы смотрим есть ли место для новых данных
-	if( (sz+1) > SizeOfMessageQueue )
+	if( (sz + 1) > SizeOfMessageQueue )
 	{
 		stCountOfLostMessages++;
+
 		if( lostStrategy == lostNewData )
 			return;
 
@@ -49,6 +50,7 @@ void MQMutex::push( const VoidMessagePtr& vm )
 
 	mqueue.push_back(vm);
 	sz++;
+
 	if( sz > stMaxQueueMessages )
 		stMaxQueueMessages = sz;
 }
@@ -82,7 +84,7 @@ void MQMutex::setMaxSizeOfMessageQueue( size_t s )
 	SizeOfMessageQueue = s;
 }
 //---------------------------------------------------------------------------
-size_t MQMutex::getMaxSizeOfMessageQueue()
+size_t MQMutex::getMaxSizeOfMessageQueue() const
 {
 	return SizeOfMessageQueue;
 }

src/Various/MessageType.cc

@@ -211,11 +211,11 @@ namespace UniSetTypes
 	}
 	//--------------------------------------------------------------------------------------------
 	ConfirmMessage::ConfirmMessage( UniSetTypes::ObjectId in_sensor_id,
-								   double in_value,
-								   time_t in_time,
-								   time_t in_time_usec,
-								   time_t in_confirm,
-								   Priority in_priority ):
+									double in_value,
+									time_t in_time,
+									time_t in_time_usec,
+									time_t in_confirm,
+									Priority in_priority ):
 		sensor_id(in_sensor_id),
 		value(in_value),
 		time(in_time),

tests/MQPerfTest/mq-test.cc

@@ -16,13 +16,13 @@ const size_t COUNT = 1000000; // сколько сообщений помест
 // поток записи
 void mq_write_thread()
 {
-	SensorMessage smsg(100,2);
+	SensorMessage smsg(100, 2);
 	TransportMessage tm( std::move(smsg.transport_msg()) );
 	auto vm = make_shared<VoidMessage>(tm);
 
 	msleep(100);
 
-	for( size_t i=0; i<COUNT; i++ )
+	for( size_t i = 0; i < COUNT; i++ )
 	{
 		mq.push(vm);
 	}
@@ -40,6 +40,7 @@ int one_test()
 	while( rnum < COUNT )
 	{
 		auto m = mq.top();
+
 		if( m )
 			rnum++;
 	}
@@ -59,16 +60,16 @@ int main(int argc, const char** argv)
 		int tnum = 10;
 
 		// чтобы не происходило переполнение
-		mq.setMaxSizeOfMessageQueue(COUNT+1);
+		mq.setMaxSizeOfMessageQueue(COUNT + 1);
 
 		// сперва просто проверка что очередь работает.
 		{
-			SensorMessage sm(100,2);
+			SensorMessage sm(100, 2);
 			TransportMessage tm( std::move(sm.transport_msg()) );
 			auto vm = make_shared<VoidMessage>(tm);
 			mq.push(vm);
 			auto msg = mq.top();
-			assert( msg!=nullptr );
+			assert( msg != nullptr );
 			SensorMessage sm2( msg.get() );
 			assert( sm.id == sm2.id );
 		}
@@ -76,14 +77,15 @@ int main(int argc, const char** argv)
 		vector<int> res;
 		res.reserve(tnum);
 
-		for( int i=0; i<tnum; i++ )
+		for( int i = 0; i < tnum; i++ )
 		{
 			res.push_back(one_test());
 		}
 
 		// вычисляем среднее
 		int sum = 0;
-		for( auto&& r: res )
+
+		for( auto && r : res )
 			sum += r;
 
 		float avg = (float)sum / tnum;

tests/TestUObject.h

@@ -12,9 +12,9 @@ class TestUObject:
 	public:
 
 		TestUObject( UniSetTypes::ObjectId id, xmlNode* cnode ):
-			UniSetObject(id){}
+			UniSetObject(id) {}
 
-		virtual ~TestUObject(){};
+		virtual ~TestUObject() {};
 
 		// специальные функции для проведения тестирования
 		inline VoidMessagePtr getOneMessage()
@@ -28,7 +28,7 @@ class TestUObject:
 		}
 
 	protected:
-		TestUObject(){};
+		TestUObject() {};
 };
 // -------------------------------------------------------------------------
 #endif // TestUObject_H_

tests/test_mqueue.cc

@@ -11,9 +11,9 @@
 #define TEST_MQ_ATOMIC 1
 
 #ifdef TEST_MQ_ATOMIC
-	typedef MQAtomic UMessageQueue;
+typedef MQAtomic UMessageQueue;
 #else
-	typedef MQMutex UMessageQueue;
+typedef MQMutex UMessageQueue;
 #endif
 
 // --------------------------------------------------------------------------
@@ -44,7 +44,7 @@ using namespace UniSetTypes;
 // --------------------------------------------------------------------------
 static void pushMessage( UMessageQueue& mq, long id )
 {
-	SensorMessage sm(id,id);
+	SensorMessage sm(id, id);
 	sm.consumer = id; // чтобы хоть как-то идентифицировать сообщений, используем поле consumer
 	TransportMessage tm( std::move(sm.transport_msg()) );
 	auto vm = make_shared<VoidMessage>(tm);
@@ -66,10 +66,10 @@ TEST_CASE( "UMessageQueue: simple push/top", "[mqueue]" )
 
 	UMessageQueue mq;
 
-	pushMessage(mq,100);
+	pushMessage(mq, 100);
 
 	auto msg = mq.top();
-	REQUIRE( msg!=nullptr );
+	REQUIRE( msg != nullptr );
 	REQUIRE( msg->consumer == 100 );
 }
 // --------------------------------------------------------------------------
@@ -82,21 +82,21 @@ TEST_CASE( "UMessageQueue: overflow (lost old data)", "[mqueue]" )
 
 	mq.setLostStrategy( UMessageQueue::lostOldData );
 
-	pushMessage(mq,100);
+	pushMessage(mq, 100);
 	REQUIRE( mq.size() == 1 );
 
-	pushMessage(mq,110);
+	pushMessage(mq, 110);
 	REQUIRE( mq.size() == 2 );
 
-	pushMessage(mq,120);
+	pushMessage(mq, 120);
 	REQUIRE( mq.size() == 2 );
 
 	auto msg = mq.top();
-	REQUIRE( msg!=nullptr );
+	REQUIRE( msg != nullptr );
 	REQUIRE( msg->consumer == 110 );
 
 	msg = mq.top();
-	REQUIRE( msg!=nullptr );
+	REQUIRE( msg != nullptr );
 	REQUIRE( msg->consumer == 120 );
 
 	REQUIRE( mq.getCountOfLostMessages() == 1 );
@@ -111,31 +111,31 @@ TEST_CASE( "UMessageQueue: overflow (lost new data)", "[mqueue]" )
 
 	mq.setLostStrategy( UMessageQueue::lostNewData );
 
-	pushMessage(mq,100);
+	pushMessage(mq, 100);
 	REQUIRE( mq.size() == 1 );
 
-	pushMessage(mq,110);
+	pushMessage(mq, 110);
 	REQUIRE( mq.size() == 2 );
 
-	pushMessage(mq,120);
+	pushMessage(mq, 120);
 	REQUIRE( mq.size() == 2 );
 	REQUIRE( mq.getCountOfLostMessages() == 1 );
 
-	pushMessage(mq,130);
+	pushMessage(mq, 130);
 	REQUIRE( mq.size() == 2 );
 
 	REQUIRE( mq.getCountOfLostMessages() == 2 );
 
 	auto msg = mq.top();
-	REQUIRE( msg!=nullptr );
+	REQUIRE( msg != nullptr );
 	REQUIRE( msg->consumer == 100 );
 
 	msg = mq.top();
-	REQUIRE( msg!=nullptr );
+	REQUIRE( msg != nullptr );
 	REQUIRE( msg->consumer == 110 );
 
 	msg = mq.top();
-	REQUIRE( msg==nullptr );
+	REQUIRE( msg == nullptr );
 }
 // --------------------------------------------------------------------------
 TEST_CASE( "UMessageQueue: many read", "[mqueue]" )
@@ -146,17 +146,17 @@ TEST_CASE( "UMessageQueue: many read", "[mqueue]" )
 	mq.setMaxSizeOfMessageQueue(1);
 	mq.setLostStrategy( UMessageQueue::lostNewData );
 
-	pushMessage(mq,100);
+	pushMessage(mq, 100);
 	REQUIRE( mq.size() == 1 );
 
 	auto msg = mq.top();
-	REQUIRE( msg!=nullptr );
+	REQUIRE( msg != nullptr );
 	REQUIRE( msg->consumer == 100 );
 
-	for( int i=0; i<5; i++ )
+	for( int i = 0; i < 5; i++ )
 	{
 		auto msg = mq.top();
-		REQUIRE( msg==nullptr );
+		REQUIRE( msg == nullptr );
 	}
 }
 // --------------------------------------------------------------------------
@@ -171,15 +171,16 @@ TEST_CASE( "UMessageQueue: correct operation", "[mqueue]" )
 	const size_t num = 1000;
 
 	UMessageQueue mq;
-	mq.setMaxSizeOfMessageQueue(num+1);
+	mq.setMaxSizeOfMessageQueue(num + 1);
 
 	size_t rnum = 0;
-	for( size_t i=0; i<num; i++ )
+
+	for( size_t i = 0; i < num; i++ )
 	{
-		pushMessage(mq,i);
+		pushMessage(mq, i);
 
 		// каждые 50 читатем, имитируя реальную работу (чтение между записью)
-		if( i%50 )
+		if( i % 50 )
 		{
 			auto m = mq.top();
 			REQUIRE( m->consumer == rnum );
@@ -215,9 +216,9 @@ TEST_CASE( "UMessageQueue: overflow index (strategy=lostOldData)", "[mqueue]" )
 	mq.set_rpos(max);
 
 	// При переходе через максимум ничего не должны потерять
-	pushMessage(mq,100);
-	pushMessage(mq,110);
-	pushMessage(mq,120);
+	pushMessage(mq, 100);
+	pushMessage(mq, 110);
+	pushMessage(mq, 120);
 
 	auto m = mq.top();
 	REQUIRE( m != nullptr );
@@ -241,9 +242,9 @@ TEST_CASE( "UMessageQueue: lost data (strategy=lostOldData)", "[mqueue]" )
 	mq.setLostStrategy(MQAtomic::lostOldData);
 	mq.setMaxSizeOfMessageQueue(2);
 
-	pushMessage(mq,100);
-	pushMessage(mq,110);
-	pushMessage(mq,120);
+	pushMessage(mq, 100);
+	pushMessage(mq, 110);
+	pushMessage(mq, 120);
 
 	auto m = mq.top();
 	REQUIRE( m != nullptr );
@@ -261,9 +262,9 @@ TEST_CASE( "UMessageQueue: lost data (strategy=lostOldData)", "[mqueue]" )
 	mq.set_rpos(max);
 
 	// При переходе через максимум ничего не должны потерять
-	pushMessage(mq,140);
-	pushMessage(mq,150);
-	pushMessage(mq,160);
+	pushMessage(mq, 140);
+	pushMessage(mq, 150);
+	pushMessage(mq, 160);
 
 	m = mq.top();
 	REQUIRE( m != nullptr );
@@ -289,9 +290,9 @@ TEST_CASE( "UMessageQueue: overflow index (strategy=lostNewData)", "[mqueue]" )
 	mq.set_rpos(max);
 
 	// При переходе через максимум ничего не должны потерять
-	pushMessage(mq,100);
-	pushMessage(mq,110);
-	pushMessage(mq,120);
+	pushMessage(mq, 100);
+	pushMessage(mq, 110);
+	pushMessage(mq, 120);
 
 	auto m = mq.top();
 	REQUIRE( m != nullptr );
@@ -315,9 +316,9 @@ TEST_CASE( "UMessageQueue: lost data (strategy=lostNewData)", "[mqueue]" )
 	mq.setLostStrategy(MQAtomic::lostNewData);
 	mq.setMaxSizeOfMessageQueue(2);
 
-	pushMessage(mq,100);
-	pushMessage(mq,110);
-	pushMessage(mq,120);
+	pushMessage(mq, 100);
+	pushMessage(mq, 110);
+	pushMessage(mq, 120);
 
 	auto m = mq.top();
 	REQUIRE( m != nullptr );
@@ -335,9 +336,9 @@ TEST_CASE( "UMessageQueue: lost data (strategy=lostNewData)", "[mqueue]" )
 	mq.set_rpos(max);
 
 	// При переходе через максимум ничего не должны потерять
-	pushMessage(mq,140);
-	pushMessage(mq,150);
-	pushMessage(mq,160);
+	pushMessage(mq, 140);
+	pushMessage(mq, 150);
+	pushMessage(mq, 160);
 
 	m = mq.top();
 	REQUIRE( m != nullptr );

tests/test_uobject.cc

@@ -23,14 +23,14 @@ void initTest()
 
 	if( !uobj )
 	{
-		uobj = make_object<TestUObject>("TestUObject1","TestUObject");
+		uobj = make_object<TestUObject>("TestUObject1", "TestUObject");
 		REQUIRE( uobj != nullptr );
 	}
 }
 // --------------------------------------------------------------------------
 static void pushMessage( long id, Message::Priority p )
 {
-	SensorMessage sm(id,id);
+	SensorMessage sm(id, id);
 	sm.priority = p;
 	sm.consumer = id; // чтобы хоть как-то идентифицировать сообщений, используем поле consumer
 	TransportMessage tm( std::move(sm.transport_msg()) );
@@ -46,11 +46,11 @@ TEST_CASE( "UObject: priority messages", "[uobject]" )
 	 * Хотя в реальности, оно должно совпадать с id объекта получателя.
 	 */
 
-	pushMessage(100,Message::Low);
-	pushMessage(101,Message::Low);
-	pushMessage(200,Message::Medium);
-	pushMessage(300,Message::High);
-	pushMessage(301,Message::High);
+	pushMessage(100, Message::Low);
+	pushMessage(101, Message::Low);
+	pushMessage(200, Message::Medium);
+	pushMessage(300, Message::High);
+	pushMessage(301, Message::High);
 
 	// теперь проверяем что сперва вынули Hi
 	// но так же контролируем что порядок извлечения правильный
@@ -70,7 +70,7 @@ TEST_CASE( "UObject: priority messages", "[uobject]" )
 	REQUIRE( m->priority == Message::Low );
 	REQUIRE( m->consumer == 100 );
 
-	pushMessage(201,Message::Medium);
+	pushMessage(201, Message::Medium);
 	m = uobj->getOneMessage();
 	REQUIRE( m->priority == Message::Medium );
 	REQUIRE( m->consumer == 201 );