(2.0): - UniversalInterface --> UInterface - ObjectsManager --> UniSetManager -…

IDL/Processes/IOController_i.idl

@@ -27,7 +27,7 @@
 #define BaseIOController_i_IDL_
 // --------------------------------------------------------------------------
 #include "../UniSetTypes/UniSetTypes_i.idl"
-#include "../UniSetTypes/ObjectsManager_i.idl"
+#include "../UniSetTypes/UniSetManager_i.idl"
 // --------------------------------------------------------------------------------------------------------------
 
 /*! 
@@ -35,7 +35,7 @@
  * \brief Базовый интерфейс для создания координаторов ввода/вывода  
  *
 */ 
-interface IOController_i : ObjectsManager_i	
+interface IOController_i : UniSetManager_i
 {
 	// исключения
 	

IDL/UniSetTypes/Makefile.am

@@ -7,7 +7,7 @@ CCDIR=$(top_builddir)/src/ObjectRepository
 HHDIR=$(top_builddir)/include
 
 # Исходные файлы IDL
-IDLFILES=UniSetTypes_i.idl UniSetObject_i.idl ObjectsManager_i.idl
+IDLFILES=UniSetTypes_i.idl UniSetObject_i.idl UniSetManager_i.idl
 
 include $(top_builddir)/conf/idl.mk
 

IDL/UniSetTypes/ObjectsManager_i.idl → IDL/UniSetTypes/UniSetManager_i.idl

@@ -20,11 +20,11 @@
 /*! \file
  *  \author Pavel Vainerman
  *  \date   $Date: 2007/12/18 20:24:11 $
- *  \version $Id: ObjectsManager_i.idl,v 1.2 2007/12/18 20:24:11 vpashka Exp $
+ *  \version $Id: UniSetManager_i.idl,v 1.2 2007/12/18 20:24:11 vpashka Exp $
 */
 // --------------------------------------------------------------------------
-#ifndef ObjectsManager_i_IDL_
-#define ObjectsManager_i_IDL_
+#ifndef UniSetManager_i_IDL_
+#define UniSetManager_i_IDL_
 // ---------------------------------------------------------------------------
 #include "UniSetObject_i.idl"
 #include "UniSetTypes_i.idl"
@@ -33,33 +33,33 @@
 //{
 
 	/*!
-	 * \interface ObjectsManager_i
+	 * \interface UniSetManager_i
 	 * \brief Интерфейс менеджера объектов
 	 * \author Pavel Vainerman
-	 * \version 
+	 * \version
 	 * \date   September 2001-
 	 *
 	 * Базовый класс для менеджеров объектов. Позволяет посылать сообщение
 	 * ко всем объектам сразу.
 	*/
-	interface ObjectsManager_i : UniSetObject_i
+	interface UniSetManager_i : UniSetObject_i
 	{
 		/*!< распространить сообщение всем подчиненным объектам */
-		void broadcast(in UniSetTypes::TransportMessage msg);	
-		
+		void broadcast(in UniSetTypes::TransportMessage msg);
+
 		/*! получение информации о состоянии подчиненных объектов(менеджеров)
 		 * \param MaxLength  - ограничение размера возвращаемой
-		 * последовательности структур SimpleInfo. 
-		 * \note Если у менеджера количество подчиненных объектов 
-		 * больше MaxLength, то он вернет информацию только 
+		 * последовательности структур SimpleInfo.
+		 * \note Если у менеджера количество подчиненных объектов
+		 * больше MaxLength, то он вернет информацию только
 		 * о первых MaxLength объектах. Если <=, то количество
 		 * равное количеству объектов.
-		 * \note Возвращаемые данные содержат в себе инфо. о всех 
+		 * \note Возвращаемые данные содержат в себе инфо. о всех
 		 * подчиненных объектах данного менеджера, а также объектах
 		 * подчиненных данному менеджеру менеджерах и их объектах
-		 * и т.п. и т.п. рекурсивно... Так что MaxLength должно быть 
+		 * и т.п. и т.п. рекурсивно... Так что MaxLength должно быть
 		 * достаточным.
-		 * \todo Подумать насчет применения итератора, при слишком 
+		 * \todo Подумать насчет применения итератора, при слишком
 		 * большом( >1000 ) количестве подчиненных объектов...
 		 */
 		UniSetTypes::SimpleInfoSeq getObjectsInfo( in long MaxLength );

Utilities/Admin/admin.cc

@@ -12,7 +12,7 @@
 #include "Exceptions.h"
 #include "UniSetObject.h"
 #include "UniSetTypes.h"
-#include "ObjectsManager.h"
+#include "UniSetManager.h"
 #include "MessageType.h"
 #include "Configuration.h"
 #include "ObjectIndex_XML.h"
@@ -58,14 +58,14 @@ static bool commandToAll( const string& section, ObjectRepository *rep, Command
 static void createSections( UniSetTypes::Configuration* c );
 // --------------------------------------------------------------------------
 int omap();
-int configure( const string& args, UniversalInterface &ui );
-int logRotate( const string& args, UniversalInterface &ui );
-int setValue( const string& args, UniversalInterface &ui, Configuration* conf = UniSetTypes::conf );
-int getValue( const string& args, UniversalInterface &ui, Configuration* conf = UniSetTypes::conf );
-int getRawValue( const string& args, UniversalInterface &ui );
-int getState( const string& args, UniversalInterface &ui );
-int getCalibrate( const string& args, UniversalInterface &ui );
-int oinfo( const string& args, UniversalInterface &ui );
+int configure( const string& args, UInterface &ui );
+int logRotate( const string& args, UInterface &ui );
+int setValue( const string& args, UInterface &ui, Configuration* conf = UniSetTypes::conf );
+int getValue( const string& args, UInterface &ui, Configuration* conf = UniSetTypes::conf );
+int getRawValue( const string& args, UInterface &ui );
+int getState( const string& args, UInterface &ui );
+int getCalibrate( const string& args, UInterface &ui );
+int oinfo( const string& args, UInterface &ui );
 // --------------------------------------------------------------------------
 static void print_help(int width, const string& cmd, const string& help, const string& tab=" " )
 {
@@ -154,7 +154,7 @@ int main(int argc, char** argv)
 				case 'x':	//--setValue
 				{
 					uniset_init(argc,argv,conffile);
-					UniversalInterface ui(conf);
+					UInterface ui(conf);
 					return setValue(optarg,ui);
 				}
 				break;
@@ -163,7 +163,7 @@ int main(int argc, char** argv)
 				{
 //					cout<<"(main):received option --getValue='"<<optarg<<"'"<<endl;
 					uniset_init(argc,argv,conffile);
-					UniversalInterface ui(conf);
+					UInterface ui(conf);
 					return getValue(optarg,ui);
 				}
 				break;
@@ -172,7 +172,7 @@ int main(int argc, char** argv)
 				{
 	//				cout<<"(main):received option --getRawValue='"<<optarg<<"'"<<endl;
 					uniset_init(argc,argv,conffile);
-					UniversalInterface ui(conf);
+					UInterface ui(conf);
 					return getRawValue(optarg,ui);
 				}
 				break;
@@ -181,7 +181,7 @@ int main(int argc, char** argv)
 				{
 //					cout<<"(main):received option --oinfo='"<<optarg<<"'"<<endl;
 					uniset_init(argc,argv,conffile);
-					UniversalInterface ui(conf);
+					UInterface ui(conf);
 					return oinfo(optarg,ui);
 				}
 				break;
@@ -190,7 +190,7 @@ int main(int argc, char** argv)
 				{
 //					cout<<"(main):received option --exist"<<endl;
 					uniset_init(argc,argv,conffile);
-					UniversalInterface ui(conf);
+					UInterface ui(conf);
 				
 					Command cmd=Exist;
 					ObjectRepository* rep = new ObjectRepository(conf);
@@ -206,8 +206,8 @@ int main(int argc, char** argv)
 				{
 //					cout<<"(main):received option --start"<<endl;
 					uniset_init(argc,argv,conffile);
-					UniversalInterface ui(conf);
-
+					UInterface ui(conf);
+					
 					Command cmd=StartUp;
 					ObjectRepository* rep = new ObjectRepository(conf);
 					commandToAll(conf->getServicesSection(), rep, (Command)cmd);
@@ -220,7 +220,7 @@ int main(int argc, char** argv)
 				case 'r':	//--configure
 				{
 					uniset_init(argc,argv,conffile);
-					UniversalInterface ui(conf);
+					UInterface ui(conf);
 					return configure(optarg,ui);
 				}
 				break;
@@ -229,9 +229,9 @@ int main(int argc, char** argv)
 				{
 //					cout<<"(main):received option --finish"<<endl;
 					uniset_init(argc,argv,conffile);
-					UniversalInterface ui(conf);
-
-					Command cmd=Finish;
+					UInterface ui(conf);
+					
+					Command cmd=Finish;	
 					ObjectRepository* rep = new ObjectRepository(conf);
 					commandToAll(conf->getServicesSection(), rep, (Command)cmd);
 					commandToAll(conf->getControllersSection(), rep, (Command)cmd);
@@ -244,7 +244,7 @@ int main(int argc, char** argv)
 				case 'l':	//--logrotate
 				{
 					uniset_init(argc,argv,conffile);
-					UniversalInterface ui(conf);
+					UInterface ui(conf);
 					return logRotate(optarg, ui);
 				}
 				break;
@@ -253,7 +253,7 @@ int main(int argc, char** argv)
 				{
 //					cout<<"(main):received option --getCalibrate='"<<optarg<<"'"<<endl;
 					uniset_init(argc,argv,conffile);
-					UniversalInterface ui(conf);
+					UInterface ui(conf);
 					return getCalibrate(optarg, ui);
 				}
 				break;
@@ -262,7 +262,7 @@ int main(int argc, char** argv)
 				{
 //					cout<<"(main):received option --foldUp"<<endl;
 					uniset_init(argc,argv,conffile);
-					UniversalInterface ui(conf);
+					UInterface ui(conf);
 				
 					Command cmd=FoldUp;
 					ObjectRepository* rep = new ObjectRepository(conf);
@@ -327,7 +327,7 @@ static bool commandToAll(const string& section, ObjectRepository *rep, Command c
 			return false;
 		}
 
-		ObjectsManager_i_var proc;		
+		UniSetManager_i_var proc;
 		UniSetObject_i_var obj;
 		string fullName;
 		ListObjectName::const_iterator li;
@@ -455,7 +455,7 @@ int omap()
 }
 
 // --------------------------------------------------------------------------------------
-int setValue( const string& args, UniversalInterface &ui, Configuration* conf )
+int setValue( const string& args, UInterface &ui, Configuration* conf )
 {
 	int err = 0;
 	
@@ -501,7 +501,7 @@ int setValue( const string& args, UniversalInterface &ui, Configuration* conf )
 }
 
 // --------------------------------------------------------------------------------------
-int getValue( const string& args, UniversalInterface &ui, Configuration* conf )
+int getValue( const string& args, UInterface &ui, Configuration* conf )
 {
 	int err = 0;
 	
@@ -545,7 +545,7 @@ int getValue( const string& args, UniversalInterface &ui, Configuration* conf )
 	return err;
 }
 // --------------------------------------------------------------------------------------
-int getCalibrate( const std::string& args, UniversalInterface &ui )
+int getCalibrate( const std::string& args, UInterface &ui )
 {
 	int err = 0;
   	typedef std::list<UniSetTypes::ParamSInfo> SList;
@@ -575,7 +575,7 @@ int getCalibrate( const std::string& args, UniversalInterface &ui )
 }
 
 // --------------------------------------------------------------------------------------
-int getRawValue( const std::string& args, UniversalInterface &ui )
+int getRawValue( const std::string& args, UInterface &ui )
 {
 	int err = 0;
   	typedef std::list<UniSetTypes::ParamSInfo> SList;
@@ -602,7 +602,7 @@ int getRawValue( const std::string& args, UniversalInterface &ui )
 }
 
 // --------------------------------------------------------------------------------------
-int logRotate( const string& arg, UniversalInterface &ui )
+int logRotate( const string& arg, UInterface &ui )
 {
 	// посылка всем
 	if( arg.empty() || (arg.c_str())[0]!='-' )
@@ -631,7 +631,7 @@ int logRotate( const string& arg, UniversalInterface &ui )
 }
 
 // --------------------------------------------------------------------------------------
-int configure( const string& arg, UniversalInterface &ui )
+int configure( const string& arg, UInterface &ui )
 {
 	// посылка всем
 	if( arg.empty() || (arg.c_str())[0]!='-' )
@@ -659,7 +659,7 @@ int configure( const string& arg, UniversalInterface &ui )
 }
 
 // --------------------------------------------------------------------------------------
-int oinfo( const string& arg, UniversalInterface &ui )
+int oinfo( const string& arg, UInterface &ui )
 {
 	UniSetTypes::ObjectId oid(uni_atoi(arg));
 	if( oid==0 )

Utilities/NullController/main.cc

 #include "Configuration.h"
 #include "NullController.h"
-#include "ObjectsActivator.h"
+#include "UniSetActivator.h"
 #include "Debug.h"
 #include "PassiveTimer.h"
 // --------------------------------------------------------------------------
@@ -71,7 +71,7 @@ int main(int argc, char** argv)
 		bool dbDumping = conf->getArgInt("--dbDumping");
 
 		NullController nc(ID,askfile,s_field,s_fvalue,c_field,c_fvalue,dbDumping);
-		ObjectsActivator act;
+		UniSetActivator act;
 		act.addObject(static_cast<class UniSetObject*>(&nc));
 		act.run(false);
 		return 0;

Utilities/SImitator/main.cc

 #include <iostream>
 #include "Exceptions.h"
-#include "UniversalInterface.h"
+#include "UInterface.h"
 // -----------------------------------------------------------------------------
 using namespace std;
 using namespace UniSetTypes;
@@ -37,7 +37,7 @@ int main( int argc, char **argv )
 		// -------------------------------------
 
 		uniset_init(argc, argv, "configure.xml" );
-		UniversalInterface ui;
+		UInterface ui;
 		
 		string sid(conf->getArgParam("--sid"));
 		if( sid.empty() )

Utilities/SMonit/smonitor.cc

 #include <iostream>
 #include <string>
-#include "ObjectsActivator.h"
+#include "UniSetActivator.h"
 #include "Configuration.h"
 #include "SMonitor.h"
 // -----------------------------------------------------------------------------
@@ -33,7 +33,7 @@ int main( int argc, const char **argv )
 			return 0;
 		}
 
-		ObjectsActivator act;
+		UniSetActivator act;
 		SMonitor tp(ID);
 		act.addObject(&tp);
 

Utilities/SViewer-text/main.cc

@@ -23,7 +23,7 @@ int main(int argc, const char **argv)
 
 		uniset_init(argc,argv,"configure.xml");
 /*
-		UniversalInterface ui;
+		UInterface ui;
 		IDList lst;
 		lst.add(1);
 		lst.add(2);

Utilities/codegen/skel-main.cc

 #include <sstream>
-#include <ObjectsActivator.h>
+#include <UniSetActivator.h>
 #include "Skel.h"
 // -----------------------------------------------------------------------------
 using namespace UniSetTypes;
@@ -17,7 +17,7 @@ int main( int argc, const char **argv )
 		ulog.logFile( logname.c_str() );
 //		conf->initDebug(dlog,"dlog");
 
-		ObjectsActivator act;
+		UniSetActivator act;
 		xmlNode* cnode = conf->getNode("Skel");
 		if( cnode == NULL )
 		{

conf/libuniset.spec

@@ -355,6 +355,10 @@ mv -f %buildroot%python_sitelibdir_noarch/* %buildroot%python_sitelibdir/%oname
 - remove deprecated interfaces (Storages,CycleStorage,TableStorage,TextIndex,..)
 - rename unideb --> ulog
 - DebugStream refactoring (add new function)
+- UniversalInterface --> UInterface
+- ObjectsManager --> UniSetManager
+- ObjectsActitvator --> UniSetActivator
+
 
 * Tue Dec 10 2013 Pavel Vainerman <pv@altlinux.ru> 1.7-alt3
 - add RRDServer

extensions/DBServer-MySQL/main.cc

 #include "Configuration.h"
 #include "DBServer_MySQL.h"
-#include "ObjectsActivator.h"
+#include "UniSetActivator.h"
 #include "Debug.h"
 // --------------------------------------------------------------------------
 using namespace UniSetTypes;
@@ -52,7 +52,7 @@ int main(int argc, char** argv)
 		}
 
 		DBServer_MySQL dbs(ID);
-		ObjectsActivator act;
+		UniSetActivator act;
 		act.addObject(static_cast<class UniSetObject*>(&dbs));
 		act.run(false);
 	}

extensions/DBServer-SQLite/main.cc

 #include "Configuration.h"
 #include "DBServer_SQLite.h"
-#include "ObjectsActivator.h"
+#include "UniSetActivator.h"
 #include "Debug.h"
 // --------------------------------------------------------------------------
 using namespace UniSetTypes;
@@ -52,7 +52,7 @@ int main(int argc, char** argv)
 		}
 
 		DBServer_SQLite dbs(ID);
-		ObjectsActivator act;
+		UniSetActivator act;
 		act.addObject(static_cast<class UniSetObject*>(&dbs));
 		act.run(false);
 	}

extensions/IOControl/IOControl.h

@@ -330,7 +330,7 @@ class IOControl:
 		std::string s_fvalue;
 
 		SMInterface* shm;         
-		UniversalInterface ui;
+		UInterface ui;
 		UniSetTypes::ObjectId myid;
 		std::string prefix;
 

extensions/IOControl/iocontrol.cc

 #include <string>
 #include "Debug.h"
-#include "ObjectsActivator.h"
+#include "UniSetActivator.h"
 #include "Configuration.h"
 #include "IOControl.h"
 #include "Extensions.h"
@@ -52,7 +52,7 @@ int main(int argc, const char **argv)
 			return 1;
 		}
 
-		ObjectsActivator act;
+		UniSetActivator act;
 		act.addObject(static_cast<class UniSetObject*>(ic));
 
 		SystemMessage sm(SystemMessage::StartUp); 

extensions/LogicProcessor/LProcessor.h

@@ -87,7 +87,7 @@
 // --------------------------------------------------------------------------
 #include <map>
 #include "UniSetTypes.h"
-#include "UniversalInterface.h"
+#include "UInterface.h"
 #include "Element.h"
 #include "Schema.h"
 // --------------------------------------------------------------------------
@@ -131,7 +131,7 @@ class LProcessor
 		OUTList extOuts;
 		SchemaXML sch;
 
-		UniversalInterface ui;
+		UInterface ui;
 		int sleepTime;
 		int smReadyTimeout; 	/*!< время ожидания готовности SM */
 

extensions/LogicProcessor/PassiveLProcessor.h

@@ -6,7 +6,7 @@
 #include "UniSetObject_LT.h"
 #include "Extensions.h"
 #include "SharedMemory.h"
-#include "UniversalInterface.h"
+#include "UInterface.h"
 #include "SMInterface.h"
 #include "LProcessor.h"
 // --------------------------------------------------------------------------

extensions/LogicProcessor/plogicproc.cc

 #include <iostream>
 #include "Configuration.h"
 #include "Extensions.h"
-#include "ObjectsActivator.h"
+#include "UniSetActivator.h"
 #include "PassiveLProcessor.h"
 
 // -----------------------------------------------------------------------------
@@ -70,7 +70,7 @@ int main(int argc, const char **argv)
 
 		PassiveLProcessor plc(schema,ID,shmID);
 
-		ObjectsActivator act;
+		UniSetActivator act;
 		act.addObject(static_cast<class UniSetObject*>(&plc));
 
 		SystemMessage sm(SystemMessage::StartUp); 

extensions/ModbusMaster/main.cc

@@ -3,7 +3,7 @@
 #include "MBTCPMaster.h"
 #include "Configuration.h"
 #include "Debug.h"
-#include "ObjectsActivator.h"
+#include "UniSetActivator.h"
 #include "Extensions.h"
 // -----------------------------------------------------------------------------
 using namespace std;
@@ -59,7 +59,7 @@ int main( int argc, const char** argv )
 			return 1;
 		}
 
-		ObjectsActivator act;
+		UniSetActivator act;
 		act.addObject(static_cast<class UniSetObject*>(mb));
 
 		SystemMessage sm(SystemMessage::StartUp);

extensions/ModbusMaster/multi-main.cc

@@ -3,7 +3,7 @@
 #include "MBTCPMultiMaster.h"
 #include "Configuration.h"
 #include "Debug.h"
-#include "ObjectsActivator.h"
+#include "UniSetActivator.h"
 #include "Extensions.h"
 // -----------------------------------------------------------------------------
 using namespace std;
@@ -59,7 +59,7 @@ int main( int argc, const char** argv )
 			return 1;
 		}
 
-		ObjectsActivator act;
+		UniSetActivator act;
 		act.addObject(static_cast<class UniSetObject*>(mb));
 
 		SystemMessage sm(SystemMessage::StartUp);

extensions/ModbusMaster/rtuexchange.cc

 #include <sys/wait.h>
 #include <sstream>
-#include "ObjectsActivator.h"
+#include "UniSetActivator.h"
 #include "Extensions.h"
 #include "RTUExchange.h"
 // -----------------------------------------------------------------------------
@@ -57,7 +57,7 @@ int main( int argc, char** argv )
 			return 1;
 		}
 
-		ObjectsActivator act;
+		UniSetActivator act;
 		act.addObject(static_cast<class UniSetObject*>(rs));
 
 		SystemMessage sm(SystemMessage::StartUp);

extensions/ModbusSlave/mbslave.cc

@@ -6,7 +6,7 @@
 #include "MBSlave.h"
 #include "Configuration.h"
 #include "Debug.h"
-#include "ObjectsActivator.h"
+#include "UniSetActivator.h"
 #include "Extensions.h"
 
 // --------------------------------------------------------------------------
@@ -64,7 +64,7 @@ int main(int argc, const char **argv)
 			return 1;
 		}
 
-		ObjectsActivator act;
+		UniSetActivator act;
 		act.addObject(static_cast<class UniSetObject*>(s));
 		SystemMessage sm(SystemMessage::StartUp); 
 		act.broadcast( sm.transport_msg() );

extensions/RRDServer/main.cc

@@ -2,7 +2,7 @@
 #include "RRDServer.h"
 #include "Configuration.h"
 #include "Debug.h"
-#include "ObjectsActivator.h"
+#include "UniSetActivator.h"
 #include "Extensions.h"
 // -----------------------------------------------------------------------------
 using namespace std;
@@ -58,7 +58,7 @@ int main( int argc, const char** argv )
 			return 1;
 		}
 
-		ObjectsActivator act;
+		UniSetActivator act;
 		act.addObject(static_cast<class UniSetObject*>(db));
 
 		SystemMessage sm(SystemMessage::StartUp);

extensions/SMDBServer/main.cc

@@ -2,7 +2,7 @@
 #include "SMDBServer.h"
 #include "Configuration.h"
 #include "Debug.h"
-#include "ObjectsActivator.h"
+#include "UniSetActivator.h"
 #include "Extensions.h"
 // -----------------------------------------------------------------------------
 using namespace std;
@@ -58,7 +58,7 @@ int main( int argc, const char** argv )
 			return 1;
 		}
 
-		ObjectsActivator act;
+		UniSetActivator act;
 		act.addObject(static_cast<class UniSetObject*>(db));
 
 		SystemMessage sm(SystemMessage::StartUp); 

extensions/SMViewer/SMViewer.h

@@ -19,7 +19,7 @@ class SMViewer:
 
 	private:
 		SMInterface* shm;
-		UniversalInterface ui;
+		UInterface ui;
 };
 // --------------------------------------------------------------------------
 #endif

extensions/SharedMemory/smemory.cc

 #include <string>
 #include "Debug.h"
-#include "ObjectsActivator.h"
+#include "UniSetActivator.h"
 #include "SharedMemory.h"
 #include "Extensions.h"
 // --------------------------------------------------------------------------
@@ -32,7 +32,7 @@ int main(int argc, const char **argv)
 		if( !shm )
 			return 1;
 
-		ObjectsActivator act;
+		UniSetActivator act;
 
 		act.addObject(static_cast<class UniSetObject*>(shm));
 		SystemMessage sm(SystemMessage::StartUp); 

extensions/SharedMemoryPlus/smemory-plus.cc

@@ -4,7 +4,7 @@
 #include <error.h>
 #include <errno.h>
 #include <Debug.h>
-#include <ObjectsActivator.h>
+#include <UniSetActivator.h>
 #include <ThreadCreator.h>
 #include "Extensions.h"
 #include "RTUExchange.h"
@@ -55,14 +55,14 @@ int main( int argc, const char **argv )
 		ulog.logFile( logname );
 		conf->initDebug(UniSetExtensions::dlog,"dlog");
 
-		ObjectsActivator act;
+		UniSetActivator act;
 		// ------------ SharedMemory ----------------
 		SharedMemory* shm = SharedMemory::init_smemory(argc,argv);
 		if( shm == NULL )
 			return 1;
 
-		act.addManager(static_cast<class ObjectsManager*>(shm));
-
+		act.addManager(static_cast<class UniSetManager*>(shm));
+		
 		// ------------ IOControl ----------------
 		std::list< ThreadCreator<IOControl>* > lst_iothr;
 		for( int i=0; i<MaxAddNum; i++ )

extensions/UNetUDP/unetexchange.cc

 #include <sstream>
 #include <sys/wait.h>
-#include "ObjectsActivator.h"
+#include "UniSetActivator.h"
 #include "Extensions.h"
 #include "UNetExchange.h"
 // -----------------------------------------------------------------------------
@@ -56,7 +56,7 @@ int main( int argc, const char** argv )
 			return 1;
 		}
 
-		ObjectsActivator act;
+		UniSetActivator act;
 		act.addObject(static_cast<class UniSetObject*>(unet));
 
 		SystemMessage sm(SystemMessage::StartUp);

extensions/UniNetwork/uninet.cc

 #include <sys/wait.h>
 #include <string>
 #include "Debug.h"
-#include "ObjectsActivator.h"
+#include "UniSetActivator.h"
 #include "UniExchange.h"
 #include "Extensions.h"
 // --------------------------------------------------------------------------
@@ -46,7 +46,7 @@ int main(int argc, const char **argv)
 		if( !shm )
 			return 1;
 
-		ObjectsActivator act;
+		UniSetActivator act;
 
 		act.addObject(static_cast<class UniSetObject*>(shm));
 		SystemMessage sm(SystemMessage::StartUp); 

extensions/include/SMInterface.h

@@ -6,12 +6,12 @@
 #include <string>
 #include "UniSetTypes.h"
 #include "IONotifyController.h"
-#include "UniversalInterface.h"
+#include "UInterface.h"
 class SMInterface
 {
 	public:
 
-		SMInterface( UniSetTypes::ObjectId _shmID, UniversalInterface* ui, 
+		SMInterface( UniSetTypes::ObjectId _shmID, UInterface* ui,
 						UniSetTypes::ObjectId myid, IONotifyController* ic=0 );
 		~SMInterface();
 
@@ -55,7 +55,7 @@ class SMInterface
 		
 	protected:
 		IONotifyController* ic;
-		UniversalInterface* ui;
+		UInterface* ui;
 		CORBA::Object_var oref;
 		UniSetTypes::ObjectId shmID;
 		UniSetTypes::ObjectId myid;

extensions/lib/SMInterface.cc

@@ -82,7 +82,7 @@ using namespace UniSetTypes;
 		} \
 
 // --------------------------------------------------------------------------
-SMInterface::SMInterface( UniSetTypes::ObjectId _shmID, UniversalInterface* _ui, 
+SMInterface::SMInterface( UniSetTypes::ObjectId _shmID, UInterface* _ui,
 							UniSetTypes::ObjectId _myid, IONotifyController* ic ):
 	ic(ic),
 	ui(_ui),

extensions/tests/SMemoryTest/TestProc.cc

@@ -38,8 +38,8 @@ void TestProc::sysCommand( UniSetTypes::SystemMessage* sm )
 // -----------------------------------------------------------------------------
 void TestProc::sensorInfo( SensorMessage *sm )
 {
-	dlog[Debug::LEVEL1] << myname << "(sensorInfo): id=" << sm->id << " val=" << sm->value
-			<< "  " << UniversalInterface::timeToString(sm->sm_tv_sec,":")
+	dlog[Debug::LEVEL1] << myname << "(sensorInfo): id=" << sm->id << " val=" << sm->value 
+			<< "  " << UInterface::timeToString(sm->sm_tv_sec,":")
 			<< "(" << setw(6) << sm->sm_tv_usec << "): "
 			<< endl;
 

extensions/tests/SMemoryTest/smemory-test.cc

 #include <string>
 #include "Debug.h"
-#include "ObjectsActivator.h"
+#include "UniSetActivator.h"
 #include "SharedMemory.h"
 #include "Extensions.h"
 #include "TestProc.h"
@@ -36,7 +36,7 @@ int main(int argc, const char **argv)
 		TestProc tp(conf->getObjectID("TestProc1"));
 		tp.init_dlog(dlog);
 
-		ObjectsActivator act;
+		UniSetActivator act;
 
 		act.addObject(static_cast<class UniSetObject*>(shm));
 		act.addObject(static_cast<class UniSetObject*>(&tp));

include/DBServer.h

@@ -37,7 +37,7 @@
 	 \subsection subDBS_idea Сценарий работы
 	 	На узле, где ведётся БД запускается один экземпляр сервиса. Клиенты могут получить доступ, несколькими способами:
 		- через NameService
-		- при помощи UniversalInterface::send()
+		- при помощи UInterface::send()
 
 		Сервис является системным, поэтому его идентификатор можно получить при помощи 
 	UniSetTypes::Configuration::getDBServer() объекта UniSetTypes::conf.

include/IOController.h

@@ -30,13 +30,13 @@
 #include <sigc++/sigc++.h>
 #include "IOController_i.hh"
 #include "UniSetTypes.h"
-#include "ObjectsManager.h"
+#include "UniSetManager.h"
 #include "Configuration.h"
 #include "Mutex.h"
 //---------------------------------------------------------------------------
 /*! Реализация интерфейса IOController-а */ 
 class IOController: 
-		public ObjectsManager,
+		public UniSetManager,
 		public POA_IOController_i
 {
 	public:

include/ProxyManager.h

@@ -45,7 +45,7 @@ class ProxyManager:
 		void attachObject( PassiveObject* po, UniSetTypes::ObjectId id );
 		void detachObject( UniSetTypes::ObjectId id );
 	
-		UniversalInterface* uin;
+		UInterface* uin;
 
 	protected:
 		ProxyManager();	

include/SViewer.h

@@ -28,7 +28,7 @@
 #include <string>
 #include "IOController_i.hh"
 #include "ObjectRepository.h"
-#include "UniversalInterface.h"
+#include "UInterface.h"
 #include "PassiveTimer.h"
 //--------------------------------------------------------------------------------
 class SViewer 
@@ -57,8 +57,8 @@ class SViewer
 
 	private:
 		ObjectRepository rep;
-		UniversalInterface::CacheOfResolve cache;
-		UniversalInterface ui;
+		UInterface::CacheOfResolve cache;
+		UInterface ui;
 		bool isShort;
 
 };

include/UniversalInterface.h → include/UInterface.h

@@ -22,8 +22,8 @@
  * \author Pavel Vainerman
  */
 // --------------------------------------------------------------------------
-#ifndef UniversalInterface_H_
-#define UniversalInterface_H_
+#ifndef UInterface_H_
+#define UInterface_H_
 // ---------------------------------------------------------------------------
 #include <string>
 #include <sstream>
@@ -40,7 +40,7 @@
 
 // -----------------------------------------------------------------------------------------
 /*! \namespace UniversalIO
- * Пространство имен содержащее классы, функции и т.п. для работы с вводом/выводом 
+ * Пространство имен содержащее классы, функции и т.п. для работы с вводом/выводом
 */
 namespace UniversalIO
 {
@@ -52,27 +52,27 @@ namespace UniversalIO
 #define IO_THROW_EXCEPTIONS UniSetTypes::TimeOut,UniSetTypes::IOBadParam,UniSetTypes::ORepFailed
 // -----------------------------------------------------------------------------------------
 /*!
- * \class UniversalInterface
+ * \class UInterface
  * ... а здесь идет кратенькое описание... (коротенько минут на 40!...)
  * Для увеличения производительности в функции встроен cache обращений...
  *
  * См. также \ref UniversalIOControllerPage
-*/ 
-class UniversalInterface
+*/
+class UInterface
 {
 	public:
-	
-		UniversalInterface( UniSetTypes::ObjectId backid, CORBA::ORB_var orb=NULL, UniSetTypes::ObjectIndex* oind=NULL );
-		UniversalInterface( UniSetTypes::Configuration* uconf=UniSetTypes::conf );
-		~UniversalInterface();
-		
+
+		UInterface( UniSetTypes::ObjectId backid, CORBA::ORB_var orb=NULL, UniSetTypes::ObjectIndex* oind=NULL );
+		UInterface( UniSetTypes::Configuration* uconf=UniSetTypes::conf );
+		~UInterface();
+
 		inline UniSetTypes::ObjectIndex* getObjectIndex() { return oind; }
 		inline UniSetTypes::Configuration* getConf() { return uconf; }
 
 		// -------- Функции работы с группой датчиков -----------
 
 		// Группа должна принадлежать одному процессу!
-		
+
 		//! Получение состояния для списка указанных датчиков
 		IOController_i::SensorInfoSeq_var getSensorSeq( UniSetTypes::IDList& lst );
 
@@ -87,7 +87,7 @@ class UniversalInterface
 		//! Получение состояния датчика
 		long getValue ( UniSetTypes::ObjectId id, UniSetTypes::ObjectId node )throw(IO_THROW_EXCEPTIONS);
 		long getValue ( UniSetTypes::ObjectId id );
-		
+
 		//! Выставление состояния датчика
 		void setValue ( UniSetTypes::ObjectId id, long value, UniSetTypes::ObjectId node ) throw(IO_THROW_EXCEPTIONS);
 		void setValue ( UniSetTypes::ObjectId id, long value );
@@ -100,7 +100,7 @@ class UniversalInterface
 		CORBA::Long getRawValue( const IOController_i::SensorInfo& si );
 
 		//! калибровка
-		void calibrate(const IOController_i::SensorInfo& si, 
+		void calibrate(const IOController_i::SensorInfo& si,
 					   const IOController_i::CalibrateInfo& ci,
 					   UniSetTypes::ObjectId adminId = UniSetTypes::DefaultObjectId );
 
@@ -110,12 +110,12 @@ class UniversalInterface
 		//! Заказ информации об изменении дискретного датчика
 		void askThreshold( UniSetTypes::ObjectId sensorId, UniSetTypes::ThresholdId tid,
 							UniversalIO::UIOCommand cmd,
-							CORBA::Long lowLimit=0, CORBA::Long hiLimit=0, CORBA::Long sensibility=0, 
+							CORBA::Long lowLimit=0, CORBA::Long hiLimit=0, CORBA::Long sensibility=0,
 							UniSetTypes::ObjectId backid = UniSetTypes::DefaultObjectId );
 
 		void askRemoteThreshold( UniSetTypes::ObjectId sensorId, UniSetTypes::ObjectId node,
 								 UniSetTypes::ThresholdId thresholdId, UniversalIO::UIOCommand cmd,
-								 CORBA::Long lowLimit=0, CORBA::Long hiLimit=0, CORBA::Long sensibility=0, 
+								 CORBA::Long lowLimit=0, CORBA::Long hiLimit=0, CORBA::Long sensibility=0,
 								 UniSetTypes::ObjectId backid = UniSetTypes::DefaultObjectId );
 
 		//! Универсальный заказ информации об изменении датчика
@@ -123,7 +123,7 @@ class UniversalInterface
 							UniSetTypes::ObjectId backid = UniSetTypes::DefaultObjectId );
 
 		void askRemoteSensor( UniSetTypes::ObjectId id, UniversalIO::UIOCommand cmd, UniSetTypes::ObjectId node,
-							UniSetTypes::ObjectId backid = UniSetTypes::DefaultObjectId )throw(IO_THROW_EXCEPTIONS);		
+							UniSetTypes::ObjectId backid = UniSetTypes::DefaultObjectId )throw(IO_THROW_EXCEPTIONS);
 
 		UniversalIO::IOType getIOType(UniSetTypes::ObjectId id, UniSetTypes::ObjectId node) throw(IO_THROW_EXCEPTIONS);
 		UniversalIO::IOType getIOType(UniSetTypes::ObjectId id);
@@ -135,7 +135,7 @@ class UniversalInterface
 		UniversalIO::IOType getConfIOType( UniSetTypes::ObjectId id );
 
 		IOController_i::ShortIOInfo getChangedTime( UniSetTypes::ObjectId id, UniSetTypes::ObjectId node );
-		IOController_i::ShortMapSeq* getSensors( UniSetTypes::ObjectId id, 
+		IOController_i::ShortMapSeq* getSensors( UniSetTypes::ObjectId id,
 													UniSetTypes::ObjectId node=UniSetTypes::conf->getLocalNode() );
 
 //		/*! регистрация объекта в репозитории */
@@ -161,7 +161,7 @@ class UniversalInterface
 		UniSetTypes::ObjectPtr resolve( UniSetTypes::ObjectId id, UniSetTypes::ObjectId nodeName, int timeoutMS=UniversalIO::defaultTimeOut)
 			throw(UniSetTypes::ResolveNameError, UniSetTypes::TimeOut);
 
-		
+
 		bool isExist( UniSetTypes::ObjectId id );
 		bool isExist( UniSetTypes::ObjectId id, UniSetTypes::ObjectId node );
 
@@ -226,11 +226,11 @@ class UniversalInterface
 					CacheOfResolve(unsigned int maxsize, int cleantime):
 						MaxSize(maxsize), CleanTime(cleantime){};
 					~CacheOfResolve(){};
-			
+
 					UniSetTypes::ObjectPtr resolve( UniSetTypes::ObjectId id, UniSetTypes::ObjectId node )throw(UniSetTypes::NameNotFound);
 					void cache(UniSetTypes::ObjectId id, UniSetTypes::ObjectId node, UniSetTypes::ObjectVar ptr);
 					void erase(UniSetTypes::ObjectId id, UniSetTypes::ObjectId node);
-					
+
 					inline void setMaxSize( unsigned int ms )
 					{
 						MaxSize = ms;
@@ -242,14 +242,14 @@ class UniversalInterface
 					CacheOfResolve(){};
 
 			private:
-			
+
 				bool clean(); 		/*!< функция очистки кэш-а от старых ссылок */
 				inline void clear() /*!< удаление всей информации */
 				{
 					UniSetTypes::uniset_rwmutex_wrlock l(cmutex);
-					mcache.clear();	
-				}; 
-								
+					mcache.clear();
+				};
+
 				/*!
 					\todo можно добавить поле CleanTime для каждой ссылки отдельно...
 				*/
@@ -261,12 +261,12 @@ class UniversalInterface
 						if(!tm)
 							 timestamp = time(NULL);
 					}
-					
+
 					Info():
 						ptr(NULL), timestamp(0){};
 
 					UniSetTypes::ObjectVar ptr;
-					time_t timestamp; // время последнего обращения 
+					time_t timestamp; // время последнего обращения
 
 					bool operator<( const CacheOfResolve::Info& rhs ) const
 					{
@@ -274,7 +274,7 @@ class UniversalInterface
 					}
 
 				};
-				
+
 				typedef std::map<int, Info> CacheMap;
 				CacheMap mcache;
 				UniSetTypes::uniset_rwmutex cmutex;
@@ -287,7 +287,7 @@ class UniversalInterface
 				typedef std::pair<int, Info> CacheItem;
 				// функция-объект для поиска устаревших(по времени) ссылок
 				struct OldRef_eq: public unary_function<CacheItem, bool>
-				{		
+				{
 					OldRef_eq(time_t tm):tm(tm){}
 					bool operator()( const CacheItem& inf ) const
 					{
@@ -295,12 +295,12 @@ class UniversalInterface
 					}
 					time_t tm;
 				};
-*/				
+*/
 		};
 
 		void initBackId( UniSetTypes::ObjectId backid );
 	protected:
-		std::string set_err(const std::string& pre, UniSetTypes::ObjectId id, UniSetTypes::ObjectId node); 
+		std::string set_err(const std::string& pre, UniSetTypes::ObjectId id, UniSetTypes::ObjectId node);
 
 	private:
 		void init();

include/ObjectsActivator.h → include/UniSetActivator.h

@@ -21,49 +21,49 @@
  * \brief Активатор объектов
  * \author Pavel Vainerman
  */
-// -------------------------------------------------------------------------- 
-#ifndef ObjectsActivator_H_
-#define ObjectsActivator_H_
-// -------------------------------------------------------------------------- 
+// --------------------------------------------------------------------------
+#ifndef UniSetActivator_H_
+#define UniSetActivator_H_
+// --------------------------------------------------------------------------
 #include <omniORB4/CORBA.h>
 #include "UniSetTypes.h"
 #include "UniSetObject.h"
-#include "ObjectsManager.h"
+#include "UniSetManager.h"
 #include "ThreadCreator.h"
 //#include "OmniThreadCreator.h"
 //----------------------------------------------------------------------------------------
-/*! \class ObjectsActivator
- *	Создает POA менеджер и регистрирует в нем объекты. 
- *	Для обработки CORBA-запросов создается поток или передаются ресурсы 
+/*! \class UniSetActivator
+ *	Создает POA менеджер и регистрирует в нем объекты.
+ *	Для обработки CORBA-запросов создается поток или передаются ресурсы
  *		главного потока см. void activate(bool thread)
- *	
- *	Активатор в свою очередь сам является менеджером(и объектом) и обладает всеми его свойствами	
+ *
+ *	Активатор в свою очередь сам является менеджером(и объектом) и обладает всеми его свойствами
  *
  * \todo  Разобраться со всякими oaDestroy, stop, oakill и сделать одну надежную завершающую функцию.
-*/ 
-class ObjectsActivator: 
-	public ObjectsManager
+*/
+class UniSetActivator:
+	public UniSetManager
 {
 	public:
-	
-		ObjectsActivator();
-		ObjectsActivator( UniSetTypes::ObjectId id );
-		virtual ~ObjectsActivator();
+
+		UniSetActivator();
+		UniSetActivator( UniSetTypes::ObjectId id );
+		virtual ~UniSetActivator();
 
 		virtual void run(bool thread);
 		virtual void stop();
 		virtual void oaDestroy(int signo=0);
 		void waitDestroy();
-		
+
 		inline void oakill(int signo){ raise(signo);}
 
-		virtual UniSetTypes::ObjectType getType(){ return UniSetTypes::getObjectType("ObjectsActivator"); }
+		virtual UniSetTypes::ObjectType getType(){ return UniSetTypes::getObjectType("UniSetActivator"); }
+
 
-		
 	protected:
 
 
-		/*! Команды доступные при заказе сигналов 
+		/*! Команды доступные при заказе сигналов
 		 * см. askSignal()
 		*/
 		enum AskSigCommand	{
@@ -74,12 +74,12 @@ class ObjectsActivator:
 		/*! заказ на обработку сигнала signo
 		 * Для обработки предназначена функция signal().
 		 * \warning Сообщение о приходе сигналов SITERM, SIGINT, SIGABRT приходит
-		 * вне зависимости от заказа. От этих сообщений нельзя отказаться... 
+		 * вне зависимости от заказа. От этих сообщений нельзя отказаться...
 		 * \warning Заказ других сигналов пока не работает..
 		 * \warning функция временно недоступна (private). Ведуться работы...
 		 * \todo сделать возможность заказа других сигналов
 		*/
-//		void askSignal(int signo, AskSigCommand cmd=Ask);	
+//		void askSignal(int signo, AskSigCommand cmd=Ask);
 
 		virtual void work();
 
@@ -88,12 +88,12 @@ class ObjectsActivator:
 			return orb;
 		}
 
-		virtual void processingMessage( UniSetTypes::VoidMessage *msg );	
+		virtual void processingMessage( UniSetTypes::VoidMessage *msg );
 		virtual void sysCommand( UniSetTypes::SystemMessage *sm );
 
 	private:
 
-//		static void processingSignal(int signo);			
+//		static void processingSignal(int signo);
 		static void terminated(int signo);
 		static void finishterm(int signo);
 		static void normalexit();
@@ -102,12 +102,12 @@ class ObjectsActivator:
 		void term( int signo );
 		void init();
 
-		friend class ThreadCreator<ObjectsActivator>;
-		ThreadCreator<ObjectsActivator> *orbthr;
-		
+		friend class ThreadCreator<UniSetActivator>;
+		ThreadCreator<UniSetActivator> *orbthr;
+
 		CORBA::ORB_var orb;
-		
-		bool omDestroy;			
+
+		bool omDestroy;
 		bool sig;
 		pid_t thpid; // pid orb потока
 
@@ -115,7 +115,7 @@ class ObjectsActivator:
 		{
 			pid_t msgpid;	// pid порожденого потока обработки сообщений
 		};
-		
+
 		struct OInfo:
 			public Info
 		{
@@ -125,22 +125,22 @@ class ObjectsActivator:
 		struct MInfo:
 			public Info
 		{
-			ObjectsManager* mnr;
+			UniSetManager* mnr;
 		};
 
 		std::list<OInfo> lstOInfo;
 		std::list<MInfo> lstMInfo;
-		void getinfo();		
+		void getinfo();
 };
 
 /*
 template<class TClass>
-int	ObjectsActivator::attach(TClass* p, void(TClass:: *f)(void*) )
+int	UniSetActivator::attach(TClass* p, void(TClass:: *f)(void*) )
 {
 	if( next >= MAX_CHILD_THREAD )
 		return -1;
 
-	callpull[next] = new OmniThreadCreator<TClass>( p, f);					 
+	callpull[next] = new OmniThreadCreator<TClass>( p, f);
 	next++;
 	return 0;
 }

include/ObjectsManager.h → include/UniSetManager.h

@@ -21,83 +21,83 @@
  * \brief Реализация интерфейса менеджера объектов.
  * \author Pavel Vainerman
  */
-// -------------------------------------------------------------------------- 
-#ifndef ObjectsManager_H_
-#define ObjectsManager_H_
-// -------------------------------------------------------------------------- 
+// --------------------------------------------------------------------------
+#ifndef UniSetManager_H_
+#define UniSetManager_H_
+// --------------------------------------------------------------------------
 #include <omniORB4/CORBA.h>
 #include "UniSetTypes.h"
 #include "UniSetObject.h"
-#include "ObjectsManager_i.hh"
+#include "UniSetManager_i.hh"
 //---------------------------------------------------------------------------
-class ObjectsActivator;
+class UniSetActivator;
 
-class ObjectsManager;
-typedef std::list<ObjectsManager*> ObjectsManagerList;		
+class UniSetManager;
+typedef std::list<UniSetManager*> UniSetManagerList;
 //---------------------------------------------------------------------------
-/*! \class ObjectsManager
+/*! \class UniSetManager
  *	\par
  *	Содержит в себе функции управления объектами. Их регистрации и т.п.
- *	Создается менеджер объектов, после чего вызывается initObjects() 
- *	для инициализации объектов которыми управляет 
+ *	Создается менеджер объектов, после чего вызывается initObjects()
+ *	для инициализации объектов которыми управляет
  *	данный менеджер...
- *	Менеджер в свою очередь сам является объектом и обладает всеми его свойствами	
- *	
- * 	Для пересылки сообщения всем подчиненным объектам используется 
- *		функция ObjectsManager::broadcast(const TransportMessage& msg)
+ *	Менеджер в свою очередь сам является объектом и обладает всеми его свойствами
+ *
+ * 	Для пересылки сообщения всем подчиненным объектам используется
+ *		функция UniSetManager::broadcast(const TransportMessage& msg)
  *	\par
- * 	У базового менеджера имеются базовые три функции см. ObjectsManager_i. 
- *	\note Только при вызове функции ObjectsManager::broadcast() происходит 
+ * 	У базового менеджера имеются базовые три функции см. UniSetManager_i.
+ *	\note Только при вызове функции UniSetManager::broadcast() происходит
  *		формирование сообщения всем подчиненным объектам... Если команда проиходит
  *	при помощи push, то пересылки всем починённым объектам не происходит...
  *
  *
-*/ 
-class ObjectsManager: 
+*/
+class UniSetManager:
 	public UniSetObject,
-	public POA_ObjectsManager_i
+	public POA_UniSetManager_i
 {
 	public:
-		ObjectsManager( UniSetTypes::ObjectId id);
-		ObjectsManager( const std::string& name, const std::string& section );
-		virtual ~ObjectsManager();
+		UniSetManager( UniSetTypes::ObjectId id);
+		UniSetManager( const std::string& name, const std::string& section );
+		virtual ~UniSetManager();
 
 
-		virtual UniSetTypes::ObjectType getType(){ return UniSetTypes::getObjectType("ObjectsManager"); }
+		virtual UniSetTypes::ObjectType getType(){ return UniSetTypes::getObjectType("UniSetManager"); }
 
 		// ------  функции объявленные в интерфейсе(IDL) ------
 		virtual void broadcast(const UniSetTypes::TransportMessage& msg);
 		virtual UniSetTypes::SimpleInfoSeq* getObjectsInfo( CORBA::Long MaxLength=300 );
 
 		// --------------------------
-		void initPOA(ObjectsManager* rmngr);
+		void initPOA(UniSetManager* rmngr);
 
 		virtual bool addObject(UniSetObject *obj);
 		virtual bool removeObject(UniSetObject *obj);
 
-		virtual bool addManager( ObjectsManager *mngr );
-		virtual bool removeManager( ObjectsManager *mngr );
+		virtual bool addManager( UniSetManager *mngr );
+		virtual bool removeManager( UniSetManager *mngr );
+
 
-		
 		/*! Получение доступа к подчиненному менеджеру по идентификатору
 		 * \return объект ненайден будет возвращен 0.
-		*/ 
-		const ObjectsManager* itemM(const UniSetTypes::ObjectId id);
+		*/
+		const UniSetManager* itemM(const UniSetTypes::ObjectId id);
 
 
 		/*! Получение доступа к подчиненному объекту по идентификатору
 		 * \return объект ненайден будет возвращен 0.
-		*/ 
+		*/
 		const UniSetObject* itemO( const UniSetTypes::ObjectId id );
 
-		
+
 		// Функции для аботы со списками подчиненных объектов
-		inline ObjectsManagerList::const_iterator beginMList()
+		inline UniSetManagerList::const_iterator beginMList()
 		{
 			return mlist.begin();
 		}
 
-		inline ObjectsManagerList::const_iterator endMList()
+		inline UniSetManagerList::const_iterator endMList()
 		{
 			return mlist.end();
 		}
@@ -120,7 +120,7 @@ class ObjectsManager:
 
 	protected:
 
-		ObjectsManager();
+		UniSetManager();
 
 		enum OManagerCommand{deactiv, activ, initial, term};
 
@@ -131,26 +131,26 @@ class ObjectsManager:
 
 		virtual void sigterm( int signo );
 
-		//! \note Переопределяя не забывайте вызвать базовую 
+		//! \note Переопределяя не забывайте вызвать базовую
 		virtual bool activateObject();
-		//! \note Переопределяя не забывайте вызвать базовую 
+		//! \note Переопределяя не забывайте вызвать базовую
 		virtual bool disactivateObject();
 
 
-		typedef ObjectsManagerList::iterator MListIterator;		
+		typedef UniSetManagerList::iterator MListIterator;
 
-		int getObjectsInfo( ObjectsManager* mngr, UniSetTypes::SimpleInfoSeq* seq, 
+		int getObjectsInfo( UniSetManager* mngr, UniSetTypes::SimpleInfoSeq* seq,
 							int begin, const long uplimit );
 
-		PortableServer::POA_var poa;	
+		PortableServer::POA_var poa;
 		PortableServer::POAManager_var pman;
 
 	private:
-	
-		friend class ObjectsActivator;
-	
+
+		friend class UniSetActivator;
+
 		int sig;
-		ObjectsManagerList mlist;
+		UniSetManagerList mlist;
 		ObjectsList olist;
 
 		UniSetTypes::uniset_rwmutex olistMutex;

include/ObjectsManager_LT.h → include/UniSetManager_LT.h

@@ -21,24 +21,24 @@
  * \author Pavel Vainerman
  */
 //---------------------------------------------------------------------------
-#ifndef ObjectsManager_LT_H_
-#define ObjectsManager_LT_H_
+#ifndef UniSetManager_LT_H_
+#define UniSetManager_LT_H_
 //--------------------------------------------------------------------------
 #include "UniSetTypes.h"
-#include "ObjectsManager.h"
+#include "UniSetManager.h"
 #include "LT_Object.h"
 
 //---------------------------------------------------------------------------
 /*!
 	Реализация базового класса с использованием локальных таймеров
-*/ 
-class ObjectsManager_LT:
-	public ObjectsManager
+*/
+class UniSetManager_LT:
+	public UniSetManager
 {
 	public:
-		ObjectsManager_LT( UniSetTypes::ObjectId id );
-		ObjectsManager_LT();
-		virtual ~ObjectsManager_LT();
+		UniSetManager_LT( UniSetTypes::ObjectId id );
+		UniSetManager_LT();
+		virtual ~UniSetManager_LT();
 
 	protected:
 

include/UniSetObject.h

@@ -37,15 +37,15 @@
 #include "MessageType.h"
 #include "PassiveTimer.h"
 #include "Exceptions.h"
-#include "UniversalInterface.h"
+#include "UInterface.h"
 #include "UniSetObject_i.hh"
 #include "ThreadCreator.h"
 
 //---------------------------------------------------------------------------
 //#include <omnithread.h>
 //---------------------------------------------------------------------------
-class ObjectsActivator;
-class ObjectsManager;
+class UniSetActivator;
+class UniSetManager;
 
 //---------------------------------------------------------------------------
 class UniSetObject;
@@ -101,7 +101,7 @@ class UniSetObject:
 			/*! прервать ожидание сообщений */
 			void termWaiting();
 
-			UniversalInterface ui; /*!< универсальный интерфейс для работы с другими процессами */			
+			UInterface ui; /*!< универсальный интерфейс для работы с другими процессами */
 			std::string myname;
 			std::string section;
 
@@ -183,14 +183,14 @@ class UniSetObject:
 			void setActive( bool set );
 
 			UniSetTypes::VoidMessage msg;	
-			ObjectsManager* mymngr; 
+			UniSetManager* mymngr;
 
 			void setThreadPriority( int p );
 
 	private:
 
-			friend class ObjectsManager;
-			friend class ObjectsActivator;
+			friend class UniSetManager;
+			friend class UniSetActivator;
 			friend class ThreadCreator<UniSetObject>;
 			inline pid_t getMsgPID()
 			{
@@ -200,7 +200,7 @@ class UniSetObject:
 			/*! функция потока */
 			void work();	
 			//! Инициализация параметров объекта
-			bool init(ObjectsManager* om);
+			bool init(UniSetManager* om);
 			//! Прямая деактивизация объекта	 
 			bool disactivate();
 			//! Непосредственная активизация объекта

python/lib/pyUniSet/Makefile.am

@@ -4,12 +4,12 @@ python_SCRIPTS = pyUniSet.py pyUConnector.py pyUModbus.py pyUExceptions.py
 
 pyexec_LTLIBRARIES = _pyUConnector.la _pyUModbus.la _pyUExceptions.la _pyUniSet.la
 
-_pyUniSet_la_SOURCES 	= UInterface.cc UInterface_wrap.cxx
-_pyUniSet_la_CXXFLAGS	= $(UNISET_CFLAGS) $(PYTHON_CFLAGS)
+_pyUniSet_la_SOURCES 	= pyUInterface.cc UInterface_wrap.cxx
+_pyUniSet_la_CXXFLAGS	= $(UNISET_CFLAGS) $(PYTHON_CFLAGS) 
 _pyUniSet_la_LDFLAGS 	= -module -avoid-version
 _pyUniSet_la_LIBADD 	= $(UNISET_LIBS) $(PYTHON_LIBS)
 
-UInterface_wrap.cxx: UInterface.i UInterface.h
+UInterface_wrap.cxx: UInterface.i pyUInterface.h
 	swig -python -c++ -classic UInterface.i
 
 _pyUConnector_la_SOURCES 	= UConnector.cc UConnector_wrap.cxx

python/lib/pyUniSet/UConnector.cc

@@ -11,7 +11,7 @@ xmlfile(xfile)
 	try
 	{
 	    conf = new UniSetTypes::Configuration(p->argc,p->argv,xmlfile);
-		ui = new UniversalInterface(conf);
+		ui = new UInterface(conf);
 	}
 	catch( UniSetTypes::Exception& ex )
 	{
@@ -31,7 +31,7 @@ xmlfile(xfile)
 	try
 	{
 	    conf = new UniSetTypes::Configuration(argc,argv,xmlfile);
-		ui = new UniversalInterface(conf);
+		ui = new UInterface(conf);
 	}
 	catch( UniSetTypes::Exception& ex )
 	{

python/lib/pyUniSet/UConnector.h

@@ -2,8 +2,8 @@
 #define UConnector_H_
 // --------------------------------------------------------------------------
 #include <string>
-#include <Configuration.h>
-#include <UniversalInterface.h>
+#include "Configuration.h"
+#include "UInterface.h"
 #include "UTypes.h"
 #include "UExceptions.h"
 // --------------------------------------------------------------------------
@@ -30,7 +30,7 @@ class UConnector
 
 	private:
 	  UniSetTypes::Configuration* conf;
-	  UniversalInterface* ui;
+	  UInterface* ui;
 	  const char* xmlfile;
 };
 //---------------------------------------------------------------------------

python/lib/pyUniSet/UConnector.i

@@ -11,5 +11,4 @@
 
 /* Для генерации классов и констант в Питоне */
 %include "UTypes.h"
-//%include "UExceptions.h"
 %include "UConnector.h"

python/lib/pyUniSet/UInterface.i

@@ -6,10 +6,10 @@
 
 %module pyUniSet
 %{
-#include "UInterface.h"
+#include "pyUInterface.h"
 %}
 
 /* Для генерации классов и констант в Питоне */
-%include "UInterface.h"
+%include "pyUInterface.h"
 %include "UTypes.h"
 %include "UExceptions.h"

python/lib/pyUniSet/UInterface_wrap.cxx

@@ -3055,7 +3055,7 @@ namespace swig {
 }
 
 
-#include "UInterface.h"
+#include "pyUInterface.h"
 
 
 SWIGINTERN swig_type_info*
@@ -3366,7 +3366,7 @@ SWIGINTERN PyObject *_wrap_uniset_init_params(PyObject *SWIGUNUSEDPARM(self), Py
   }
   arg2 = reinterpret_cast< char * >(buf2);
   try {
-    UInterface::uniset_init_params(arg1,(char const *)arg2);
+    pyUInterface::uniset_init_params(arg1,(char const *)arg2);
   }
   catch(UException &_e) {
     SWIG_Python_Raise(SWIG_NewPointerObj((new UException(static_cast< const UException& >(_e))),SWIGTYPE_p_UException,SWIG_POINTER_OWN), "UException", SWIGTYPE_p_UException); SWIG_fail;
@@ -3414,7 +3414,7 @@ SWIGINTERN PyObject *_wrap_uniset_init(PyObject *SWIGUNUSEDPARM(self), PyObject
   }
   arg3 = reinterpret_cast< char * >(buf3);
   try {
-    UInterface::uniset_init(arg1,arg2,(char const *)arg3);
+    pyUInterface::uniset_init(arg1,arg2,(char const *)arg3);
   }
   catch(UException &_e) {
     SWIG_Python_Raise(SWIG_NewPointerObj((new UException(static_cast< const UException& >(_e))),SWIGTYPE_p_UException,SWIG_POINTER_OWN), "UException", SWIGTYPE_p_UException); SWIG_fail;
@@ -3444,7 +3444,7 @@ SWIGINTERN PyObject *_wrap_getValue(PyObject *SWIGUNUSEDPARM(self), PyObject *ar
   }
   arg1 = static_cast< long >(val1);
   try {
-    result = (long)UInterface::getValue(arg1);
+    result = (long)pyUInterface::getValue(arg1);
   }
   catch(UException &_e) {
     SWIG_Python_Raise(SWIG_NewPointerObj((new UException(static_cast< const UException& >(_e))),SWIGTYPE_p_UException,SWIG_POINTER_OWN), "UException", SWIGTYPE_p_UException); SWIG_fail;
@@ -3480,7 +3480,7 @@ SWIGINTERN PyObject *_wrap_setValue(PyObject *SWIGUNUSEDPARM(self), PyObject *ar
   }
   arg2 = static_cast< long >(val2);
   try {
-    UInterface::setValue(arg1,arg2);
+    pyUInterface::setValue(arg1,arg2);
   }
   catch(UException &_e) {
     SWIG_Python_Raise(SWIG_NewPointerObj((new UException(static_cast< const UException& >(_e))),SWIGTYPE_p_UException,SWIG_POINTER_OWN), "UException", SWIGTYPE_p_UException); SWIG_fail;
@@ -3508,7 +3508,7 @@ SWIGINTERN PyObject *_wrap_getSensorID(PyObject *SWIGUNUSEDPARM(self), PyObject
     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getSensorID" "', argument " "1"" of type '" "char const *""'");
   }
   arg1 = reinterpret_cast< char * >(buf1);
-  result = (long)UInterface::getSensorID((char const *)arg1);
+  result = (long)pyUInterface::getSensorID((char const *)arg1);
   resultobj = SWIG_From_long(static_cast< long >(result));
   if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
   return resultobj;
@@ -3532,7 +3532,7 @@ SWIGINTERN PyObject *_wrap_getShortName(PyObject *SWIGUNUSEDPARM(self), PyObject
     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "getShortName" "', argument " "1"" of type '" "long""'");
   }
   arg1 = static_cast< long >(val1);
-  result = (char *)UInterface::getShortName(arg1);
+  result = (char *)pyUInterface::getShortName(arg1);
   resultobj = SWIG_FromCharPtr((const char *)result);
   return resultobj;
 fail:
@@ -3554,7 +3554,7 @@ SWIGINTERN PyObject *_wrap_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *arg
     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "getName" "', argument " "1"" of type '" "long""'");
   }
   arg1 = static_cast< long >(val1);
-  result = (char *)UInterface::getName(arg1);
+  result = (char *)pyUInterface::getName(arg1);
   resultobj = SWIG_FromCharPtr((const char *)result);
   return resultobj;
 fail:
@@ -3576,7 +3576,7 @@ SWIGINTERN PyObject *_wrap_getTextName(PyObject *SWIGUNUSEDPARM(self), PyObject
     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "getTextName" "', argument " "1"" of type '" "long""'");
   }
   arg1 = static_cast< long >(val1);
-  result = (char *)UInterface::getTextName(arg1);
+  result = (char *)pyUInterface::getTextName(arg1);
   resultobj = SWIG_FromCharPtr((const char *)result);
   return resultobj;
 fail:
@@ -3589,7 +3589,7 @@ SWIGINTERN PyObject *_wrap_getConfFileName(PyObject *SWIGUNUSEDPARM(self), PyObj
   char *result = 0 ;
 
   if (!PyArg_ParseTuple(args,(char *)":getConfFileName")) SWIG_fail;
-  result = (char *)UInterface::getConfFileName();
+  result = (char *)pyUInterface::getConfFileName();
   resultobj = SWIG_FromCharPtr((const char *)result);
   return resultobj;
 fail:

python/lib/pyUniSet/UModbus.h

 #ifndef UModbus_H_
 #define UModbus_H_
-// --------------------------------------------------------------------------
-#include <Configuration.h>
-#include <UniversalInterface.h>
-#include <modbus/ModbusTCPMaster.h>
-#include <modbus/ModbusTypes.h>
-#include <extensions/VTypes.h>
-#include <Debug.h>
+// -------------------------------------------------------------------------- 
+#include "Configuration.h"
+#include "UInterface.h"
+#include "modbus/ModbusTCPMaster.h"
+#include "modbus/ModbusTypes.h"
+#include "extensions/VTypes.h"
+#include "Debug.h"
 #include "UTypes.h"
 #include "UExceptions.h"
 // --------------------------------------------------------------------------

python/lib/pyUniSet/UModbus.i

@@ -12,4 +12,4 @@
 /* Для генерации классов и констант в Питоне */
 %include "UModbus.h"
 %include "UTypes.h"
-//%include "UExceptions.h"
+%include "UExceptions.h"

python/lib/pyUniSet/UModbus_wrap.cxx

@@ -2952,12 +2952,14 @@ SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
 
 #define SWIGTYPE_p_UException swig_types[0]
 #define SWIGTYPE_p_UModbus swig_types[1]
-#define SWIGTYPE_p_UTypes__Params swig_types[2]
-#define SWIGTYPE_p_char swig_types[3]
-#define SWIGTYPE_p_p_char swig_types[4]
-#define SWIGTYPE_p_std__string swig_types[5]
-static swig_type_info *swig_types[7];
-static swig_module_info swig_module = {swig_types, 6, 0, 0, 0, 0};
+#define SWIGTYPE_p_USysError swig_types[2]
+#define SWIGTYPE_p_UTimeOut swig_types[3]
+#define SWIGTYPE_p_UTypes__Params swig_types[4]
+#define SWIGTYPE_p_char swig_types[5]
+#define SWIGTYPE_p_p_char swig_types[6]
+#define SWIGTYPE_p_std__string swig_types[7]
+static swig_type_info *swig_types[9];
+static swig_module_info swig_module = {swig_types, 8, 0, 0, 0, 0};
 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
 
@@ -5209,6 +5211,413 @@ SWIGINTERN PyObject *Params_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObjec
   return SWIG_Py_Void();
 }
 
+SWIGINTERN PyObject *_wrap_new_UException__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UException *result = 0 ;
+
+  if (!PyArg_ParseTuple(args,(char *)":new_UException")) SWIG_fail;
+  result = (UException *)new UException();
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UException, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_UException__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::string *arg1 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  UException *result = 0 ;
+
+  if (!PyArg_ParseTuple(args,(char *)"O:new_UException",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__string,  0  | 0);
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UException" "', argument " "1"" of type '" "std::string const &""'");
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UException" "', argument " "1"" of type '" "std::string const &""'");
+  }
+  arg1 = reinterpret_cast< std::string * >(argp1);
+  result = (UException *)new UException((std::string const &)*arg1);
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UException, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_UException__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  char *arg1 = (char *) 0 ;
+  int res1 ;
+  char *buf1 = 0 ;
+  int alloc1 = 0 ;
+  PyObject * obj0 = 0 ;
+  UException *result = 0 ;
+
+  if (!PyArg_ParseTuple(args,(char *)"O:new_UException",&obj0)) SWIG_fail;
+  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UException" "', argument " "1"" of type '" "char const *""'");
+  }
+  arg1 = reinterpret_cast< char * >(buf1);
+  result = (UException *)new UException((char const *)arg1);
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UException, SWIG_POINTER_NEW |  0 );
+  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
+  return resultobj;
+fail:
+  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_UException(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = args ? (int)PyObject_Length(args) : 0;
+  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_UException__SWIG_0(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__string, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_UException__SWIG_1(self, args);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_UException__SWIG_2(self, args);
+    }
+  }
+
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UException'.\n"
+    "  Possible C/C++ prototypes are:\n"
+    "    UException::UException()\n"
+    "    UException::UException(std::string const &)\n"
+    "    UException::UException(char const *)\n");
+  return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_UException(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UException *arg1 = (UException *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_UException",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UException, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UException" "', argument " "1"" of type '" "UException *""'");
+  }
+  arg1 = reinterpret_cast< UException * >(argp1);
+  delete arg1;
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_UException_getError(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UException *arg1 = (UException *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  char *result = 0 ;
+
+  if (!PyArg_ParseTuple(args,(char *)"O:UException_getError",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UException, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UException_getError" "', argument " "1"" of type '" "UException *""'");
+  }
+  arg1 = reinterpret_cast< UException * >(argp1);
+  result = (char *)(arg1)->getError();
+  resultobj = SWIG_FromCharPtr((const char *)result);
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_UException_err_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UException *arg1 = (UException *) 0 ;
+  std::string arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  void *argp2 ;
+  int res2 = 0 ;
+  PyObject * obj0 = 0 ;
+  PyObject * obj1 = 0 ;
+
+  if (!PyArg_ParseTuple(args,(char *)"OO:UException_err_set",&obj0,&obj1)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UException, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UException_err_set" "', argument " "1"" of type '" "UException *""'");
+  }
+  arg1 = reinterpret_cast< UException * >(argp1);
+  {
+    res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string,  0  | 0);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UException_err_set" "', argument " "2"" of type '" "std::string""'");
+    }
+    if (!argp2) {
+      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UException_err_set" "', argument " "2"" of type '" "std::string""'");
+    } else {
+      std::string * temp = reinterpret_cast< std::string * >(argp2);
+      arg2 = *temp;
+      if (SWIG_IsNewObj(res2)) delete temp;
+    }
+  }
+  if (arg1) (arg1)->err = arg2;
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_UException_err_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UException *arg1 = (UException *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  std::string result;
+
+  if (!PyArg_ParseTuple(args,(char *)"O:UException_err_get",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UException, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UException_err_get" "', argument " "1"" of type '" "UException *""'");
+  }
+  arg1 = reinterpret_cast< UException * >(argp1);
+  result =  ((arg1)->err);
+  resultobj = SWIG_NewPointerObj((new std::string(static_cast< const std::string& >(result))), SWIGTYPE_p_std__string, SWIG_POINTER_OWN |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *UException_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_UException, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_UTimeOut__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UTimeOut *result = 0 ;
+
+  if (!PyArg_ParseTuple(args,(char *)":new_UTimeOut")) SWIG_fail;
+  result = (UTimeOut *)new UTimeOut();
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UTimeOut, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_UTimeOut__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::string *arg1 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  UTimeOut *result = 0 ;
+
+  if (!PyArg_ParseTuple(args,(char *)"O:new_UTimeOut",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__string,  0  | 0);
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UTimeOut" "', argument " "1"" of type '" "std::string const &""'");
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_UTimeOut" "', argument " "1"" of type '" "std::string const &""'");
+  }
+  arg1 = reinterpret_cast< std::string * >(argp1);
+  result = (UTimeOut *)new UTimeOut((std::string const &)*arg1);
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_UTimeOut, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_UTimeOut(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = args ? (int)PyObject_Length(args) : 0;
+  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_UTimeOut__SWIG_0(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__string, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_UTimeOut__SWIG_1(self, args);
+    }
+  }
+
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_UTimeOut'.\n"
+    "  Possible C/C++ prototypes are:\n"
+    "    UTimeOut::UTimeOut()\n"
+    "    UTimeOut::UTimeOut(std::string const &)\n");
+  return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_UTimeOut(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  UTimeOut *arg1 = (UTimeOut *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_UTimeOut",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_UTimeOut, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UTimeOut" "', argument " "1"" of type '" "UTimeOut *""'");
+  }
+  arg1 = reinterpret_cast< UTimeOut * >(argp1);
+  delete arg1;
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *UTimeOut_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_UTimeOut, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
+SWIGINTERN PyObject *_wrap_new_USysError__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  USysError *result = 0 ;
+
+  if (!PyArg_ParseTuple(args,(char *)":new_USysError")) SWIG_fail;
+  result = (USysError *)new USysError();
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_USysError, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_USysError__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  std::string *arg1 = 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+  USysError *result = 0 ;
+
+  if (!PyArg_ParseTuple(args,(char *)"O:new_USysError",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__string,  0  | 0);
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_USysError" "', argument " "1"" of type '" "std::string const &""'");
+  }
+  if (!argp1) {
+    SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_USysError" "', argument " "1"" of type '" "std::string const &""'");
+  }
+  arg1 = reinterpret_cast< std::string * >(argp1);
+  result = (USysError *)new USysError((std::string const &)*arg1);
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_USysError, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_USysError(PyObject *self, PyObject *args) {
+  int argc;
+  PyObject *argv[2];
+  int ii;
+
+  if (!PyTuple_Check(args)) SWIG_fail;
+  argc = args ? (int)PyObject_Length(args) : 0;
+  for (ii = 0; (ii < 1) && (ii < argc); ii++) {
+    argv[ii] = PyTuple_GET_ITEM(args,ii);
+  }
+  if (argc == 0) {
+    return _wrap_new_USysError__SWIG_0(self, args);
+  }
+  if (argc == 1) {
+    int _v;
+    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__string, 0);
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_USysError__SWIG_1(self, args);
+    }
+  }
+
+fail:
+  SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'new_USysError'.\n"
+    "  Possible C/C++ prototypes are:\n"
+    "    USysError::USysError()\n"
+    "    USysError::USysError(std::string const &)\n");
+  return 0;
+}
+
+
+SWIGINTERN PyObject *_wrap_delete_USysError(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *resultobj = 0;
+  USysError *arg1 = (USysError *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  PyObject * obj0 = 0 ;
+
+  if (!PyArg_ParseTuple(args,(char *)"O:delete_USysError",&obj0)) SWIG_fail;
+  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_USysError, SWIG_POINTER_DISOWN |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_USysError" "', argument " "1"" of type '" "USysError *""'");
+  }
+  arg1 = reinterpret_cast< USysError * >(argp1);
+  delete arg1;
+  resultobj = SWIG_Py_Void();
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *USysError_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+  PyObject *obj;
+  if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
+  SWIG_TypeNewClientData(SWIGTYPE_p_USysError, SWIG_NewClientData(obj));
+  return SWIG_Py_Void();
+}
+
 static PyMethodDef SwigMethods[] = {
 	 { (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL},
 	 { (char *)"new_UModbus", _wrap_new_UModbus, METH_VARARGS, NULL},
@@ -5236,14 +5645,34 @@ static PyMethodDef SwigMethods[] = {
 	 { (char *)"Params_inst", _wrap_Params_inst, METH_VARARGS, NULL},
 	 { (char *)"delete_Params", _wrap_delete_Params, METH_VARARGS, NULL},
 	 { (char *)"Params_swigregister", Params_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_UException", _wrap_new_UException, METH_VARARGS, NULL},
+	 { (char *)"delete_UException", _wrap_delete_UException, METH_VARARGS, NULL},
+	 { (char *)"UException_getError", _wrap_UException_getError, METH_VARARGS, NULL},
+	 { (char *)"UException_err_set", _wrap_UException_err_set, METH_VARARGS, NULL},
+	 { (char *)"UException_err_get", _wrap_UException_err_get, METH_VARARGS, NULL},
+	 { (char *)"UException_swigregister", UException_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_UTimeOut", _wrap_new_UTimeOut, METH_VARARGS, NULL},
+	 { (char *)"delete_UTimeOut", _wrap_delete_UTimeOut, METH_VARARGS, NULL},
+	 { (char *)"UTimeOut_swigregister", UTimeOut_swigregister, METH_VARARGS, NULL},
+	 { (char *)"new_USysError", _wrap_new_USysError, METH_VARARGS, NULL},
+	 { (char *)"delete_USysError", _wrap_delete_USysError, METH_VARARGS, NULL},
+	 { (char *)"USysError_swigregister", USysError_swigregister, METH_VARARGS, NULL},
 	 { NULL, NULL, 0, NULL }
 };
 
 
 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
 
+static void *_p_UTimeOutTo_p_UException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((UException *)  ((UTimeOut *) x));
+}
+static void *_p_USysErrorTo_p_UException(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+    return (void *)((UException *)  ((USysError *) x));
+}
 static swig_type_info _swigt__p_UException = {"_p_UException", "UException *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_UModbus = {"_p_UModbus", "UModbus *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_USysError = {"_p_USysError", "USysError *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_UTimeOut = {"_p_UTimeOut", "UTimeOut *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_UTypes__Params = {"_p_UTypes__Params", "UTypes::Params *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
@@ -5252,14 +5681,18 @@ static swig_type_info _swigt__p_std__string = {"_p_std__string", "std::string *"
 static swig_type_info *swig_type_initial[] = {
   &_swigt__p_UException,
   &_swigt__p_UModbus,
+  &_swigt__p_USysError,
+  &_swigt__p_UTimeOut,
   &_swigt__p_UTypes__Params,
   &_swigt__p_char,
   &_swigt__p_p_char,
   &_swigt__p_std__string,
 };
 
-static swig_cast_info _swigc__p_UException[] = {  {&_swigt__p_UException, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_UException[] = {  {&_swigt__p_UException, 0, 0, 0},  {&_swigt__p_UTimeOut, _p_UTimeOutTo_p_UException, 0, 0},  {&_swigt__p_USysError, _p_USysErrorTo_p_UException, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_UModbus[] = {  {&_swigt__p_UModbus, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_USysError[] = {  {&_swigt__p_USysError, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_UTimeOut[] = {  {&_swigt__p_UTimeOut, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_UTypes__Params[] = {  {&_swigt__p_UTypes__Params, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_p_char[] = {  {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
@@ -5268,6 +5701,8 @@ static swig_cast_info _swigc__p_std__string[] = {  {&_swigt__p_std__string, 0, 0
 static swig_cast_info *swig_cast_initial[] = {
   _swigc__p_UException,
   _swigc__p_UModbus,
+  _swigc__p_USysError,
+  _swigc__p_UTimeOut,
   _swigc__p_UTypes__Params,
   _swigc__p_char,
   _swigc__p_p_char,

python/lib/pyUniSet/UInterface.cc → python/lib/pyUniSet/pyUInterface.cc

 #include <ostream>
-#include <Exceptions.h>
-#include <ORepHelpers.h>
-#include <UniversalInterface.h>
-#include <Configuration.h>
-#include <UniSetTypes.h>
+#include "Exceptions.h"
+#include "ORepHelpers.h"
 #include "UInterface.h"
+#include "Configuration.h"
+#include "UniSetTypes.h"
+#include "pyUInterface.h"
 //---------------------------------------------------------------------------
 using namespace std;
 //---------------------------------------------------------------------------
-static UniversalInterface* ui=0;
+static UInterface* ui=0;
 //---------------------------------------------------------------------------
-void UInterface::uniset_init_params( UTypes::Params* p, const char* xmlfile )throw(UException)
+void pyUInterface::uniset_init_params( UTypes::Params* p, const char* xmlfile )throw(UException)
 {
-	UInterface::uniset_init(p->argc,p->argv,xmlfile);
+	pyUInterface::uniset_init(p->argc,p->argv,xmlfile);
 }
 //---------------------------------------------------------------------------
 
-void UInterface::uniset_init( int argc, char* argv[], const char* xmlfile )throw(UException)
+void pyUInterface::uniset_init( int argc, char* argv[], const char* xmlfile )throw(UException)
 {
 	try
 	{
 		UniSetTypes::uniset_init(argc,argv,xmlfile);
-		ui = new UniversalInterface();
+		ui = new UInterface();
 		return;
 	}
 	catch( UniSetTypes::Exception& ex )
@@ -34,11 +34,11 @@ void UInterface::uniset_init( int argc, char* argv[], const char* xmlfile )throw
 	}
 }
 //---------------------------------------------------------------------------
-long UInterface::getValue( long id )throw(UException)
+long pyUInterface::getValue( long id )throw(UException)
 {
 	if( !UniSetTypes::conf || !ui )
 	  throw USysError();
-	
+
 	UniversalIO::IOType t = UniSetTypes::conf->getIOType(id);
 	try
 	{
@@ -75,11 +75,11 @@ long UInterface::getValue( long id )throw(UException)
 	throw UException("(getValue): unknown error");
 }
 //---------------------------------------------------------------------------
-void UInterface::setValue( long id, long val )throw(UException)
+void pyUInterface::setValue( long id, long val )throw(UException)
 {
 	if( !UniSetTypes::conf || !ui )
 	  throw USysError();
-	
+
 	UniversalIO::IOType t = UniSetTypes::conf->getIOType(id);
 	try
 	{
@@ -114,7 +114,7 @@ void UInterface::setValue( long id, long val )throw(UException)
 	}
 }
 //---------------------------------------------------------------------------
-long UInterface::getSensorID( const char* name )
+long pyUInterface::getSensorID( const char* name )
 {
 	if( UniSetTypes::conf )
 	  return UniSetTypes::conf->getSensorID(name);
@@ -122,7 +122,7 @@ long UInterface::getSensorID( const char* name )
 	return -1;
 }
 //---------------------------------------------------------------------------
-const char* UInterface::getName( long id )
+const char* pyUInterface::getName( long id )
 {
 	if( UniSetTypes::conf )
 		return UniSetTypes::conf->oind->getMapName(id).c_str();
@@ -130,7 +130,7 @@ const char* UInterface::getName( long id )
 	return "";
 }
 //---------------------------------------------------------------------------
-const char* UInterface::getShortName( long id )
+const char* pyUInterface::getShortName( long id )
 {
 	if( UniSetTypes::conf )
 		return ORepHelpers::getShortName(UniSetTypes::conf->oind->getMapName(id)).c_str();
@@ -138,7 +138,7 @@ const char* UInterface::getShortName( long id )
 	return "";
 }
 //---------------------------------------------------------------------------
-const char* UInterface::getTextName( long id )
+const char* pyUInterface::getTextName( long id )
 {
 	if( UniSetTypes::conf )
 		return UniSetTypes::conf->oind->getTextName(id).c_str();
@@ -146,7 +146,7 @@ const char* UInterface::getTextName( long id )
 	return "";
 }
 //---------------------------------------------------------------------------
-const char* UInterface::getConfFileName()
+const char* pyUInterface::getConfFileName()
 {
 	if( UniSetTypes::conf )
 		return UniSetTypes::conf->getConfFileName().c_str();

python/lib/pyUniSet/UInterface.h → python/lib/pyUniSet/pyUInterface.h

-#ifndef UInterface_H_
-#define UInterface_H_
+#ifndef pyUInterface_H_
+#define pyUInterface_H_
 // --------------------------------------------------------------------------
 #include <string>
 #include "UTypes.h"
 #include "UExceptions.h"
 // --------------------------------------------------------------------------
-namespace UInterface
+namespace pyUInterface
 {
 	void uniset_init_params( UTypes::Params* p, const char* xmlfile )throw(UException);
 	void uniset_init( int argc, char** argv, const char* xmlfile )throw(UException);

python/lib/pyUniSet/pyUModbus.py

@@ -111,4 +111,56 @@ def Params_inst():
   return _pyUModbus.Params_inst()
 Params_inst = _pyUModbus.Params_inst
 
+class UException(Exception):
+    __swig_setmethods__ = {}
+    __setattr__ = lambda self, name, value: _swig_setattr(self, UException, name, value)
+    __swig_getmethods__ = {}
+    __getattr__ = lambda self, name: _swig_getattr(self, UException, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args):
+        this = _pyUModbus.new_UException(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _pyUModbus.delete_UException
+    __del__ = lambda self : None;
+    def getError(self): return _pyUModbus.UException_getError(self)
+    __swig_setmethods__["err"] = _pyUModbus.UException_err_set
+    __swig_getmethods__["err"] = _pyUModbus.UException_err_get
+UException_swigregister = _pyUModbus.UException_swigregister
+UException_swigregister(UException)
+
+class UTimeOut(UException):
+    __swig_setmethods__ = {}
+    for _s in [UException]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, UTimeOut, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UException]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, UTimeOut, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args):
+        this = _pyUModbus.new_UTimeOut(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _pyUModbus.delete_UTimeOut
+    __del__ = lambda self : None;
+UTimeOut_swigregister = _pyUModbus.UTimeOut_swigregister
+UTimeOut_swigregister(UTimeOut)
+
+class USysError(UException):
+    __swig_setmethods__ = {}
+    for _s in [UException]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
+    __setattr__ = lambda self, name, value: _swig_setattr(self, USysError, name, value)
+    __swig_getmethods__ = {}
+    for _s in [UException]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
+    __getattr__ = lambda self, name: _swig_getattr(self, USysError, name)
+    __repr__ = _swig_repr
+    def __init__(self, *args):
+        this = _pyUModbus.new_USysError(*args)
+        try: self.this.append(this)
+        except: self.this = this
+    __swig_destroy__ = _pyUModbus.delete_USysError
+    __del__ = lambda self : None;
+USysError_swigregister = _pyUModbus.USysError_swigregister
+USysError_swigregister(USysError)
+
 # This file is compatible with both classic and new-style classes.

src/Interfaces/Makefile.am

@@ -3,5 +3,5 @@
 ############################################################################
 
 noinst_LTLIBRARIES 			= libInterfaces.la
-libInterfaces_la_SOURCES	= UniversalInterface.cc
+libInterfaces_la_SOURCES	= UInterface.cc
 include $(top_builddir)/conf/setting.mk

src/Interfaces/UniversalInterface.cc → src/Interfaces/UInterface.cc

@@ -20,7 +20,7 @@
 /*! \file
  *  \author Pavel Vainerman
 */
-// -------------------------------------------------------------------------- 
+// --------------------------------------------------------------------------
 #include <omniORB4/CORBA.h>
 #include <omniORB4/omniURI.h>
 #include <string>
@@ -29,7 +29,7 @@
 #include <sstream>
 #include <iomanip>
 #include "ORepHelpers.h"
-#include "UniversalInterface.h"
+#include "UInterface.h"
 //#include "Debug.h"
 #include "Configuration.h"
 #include "PassiveTimer.h"
@@ -40,7 +40,7 @@ using namespace UniversalIO;
 using namespace UniSetTypes;
 using namespace std;
 // -----------------------------------------------------------------------------
-UniversalInterface::UniversalInterface( UniSetTypes::Configuration* _uconf ):
+UInterface::UInterface( UniSetTypes::Configuration* _uconf ):
 	rep(_uconf),
 	myid(UniSetTypes::DefaultObjectId),
 	orb(CORBA::ORB::_nil()),
@@ -51,7 +51,7 @@ UniversalInterface::UniversalInterface( UniSetTypes::Configuration* _uconf ):
 	init();
 }
 // -----------------------------------------------------------------------------
-UniversalInterface::UniversalInterface( ObjectId backid, CORBA::ORB_var orb, ObjectIndex* _oind ):
+UInterface::UInterface( ObjectId backid, CORBA::ORB_var orb, ObjectIndex* _oind ):
 	rep(UniSetTypes::conf),
 	myid(backid),
 	orb(orb),
@@ -63,13 +63,13 @@ UniversalInterface::UniversalInterface( ObjectId backid, CORBA::ORB_var orb, Obj
 		oind = uconf->oind;
 
 	init();
-}	
+}
 
-UniversalInterface::~UniversalInterface()
+UInterface::~UInterface()
 {
 }
 
-void UniversalInterface::init()
+void UInterface::init()
 {
 	// пытаемся получить ссылку на NameSerivice
 	// в любом случае. даже если включён режим
@@ -104,7 +104,7 @@ void UniversalInterface::init()
 	}
 }
 // ------------------------------------------------------------------------------------------------------------
-void UniversalInterface::initBackId( UniSetTypes::ObjectId backid )
+void UInterface::initBackId( UniSetTypes::ObjectId backid )
 {
 	myid = backid;
 }
@@ -115,7 +115,7 @@ void UniversalInterface::initBackId( UniSetTypes::ObjectId backid )
  * \exception IOBadParam - генерируется если указано неправильное имя датчика или секции
  * \exception IOTimeOut - генерируется если в течение времени timeout небыл получен ответ
 */
-long UniversalInterface::getValue( ObjectId name, ObjectId node )
+long UInterface::getValue( ObjectId name, ObjectId node )
 	throw(IO_THROW_EXCEPTIONS)
 {
 	if ( name == DefaultObjectId )
@@ -163,41 +163,41 @@ long UniversalInterface::getValue( ObjectId name, ObjectId node )
 	}
 	catch(ORepFailed)
 	{
-		rcache.erase(name, node);		
+		rcache.erase(name, node);
 		// не смогли получить ссылку на объект
 		throw UniSetTypes::IOBadParam(set_err("UI(getValue): ORepFailed",name,node));
-	}	
+	}
 	catch(CORBA::NO_IMPLEMENT)
 	{
-		rcache.erase(name, node);		
+		rcache.erase(name, node);
 		throw UniSetTypes::IOBadParam(set_err("UI(getValue): method no implement",name,node));
-	}	
+	}
 	catch(CORBA::OBJECT_NOT_EXIST)
 	{
-		rcache.erase(name, node);		
+		rcache.erase(name, node);
 		throw UniSetTypes::IOBadParam(set_err("UI(getValue): object not exist",name,node));
-	}	
+	}
 	catch(CORBA::COMM_FAILURE& ex)
 	{
 		// ошибка системы коммуникации
-	}	
+	}
 	catch(CORBA::SystemException& ex)
 	{
 		// ошибка системы коммуникации
 		// ulog.warn() << "UI(getValue): CORBA::SystemException" << endl;
-	}	
-	rcache.erase(name, node);		
+	}
+	rcache.erase(name, node);
 	throw UniSetTypes::TimeOut(set_err("UI(getValue): TimeOut",name,node));
 }
 
-long UniversalInterface::getValue( ObjectId name ) 
+long UInterface::getValue( ObjectId name )
 {
 	return getValue(name, uconf->getLocalNode());
 }
 
 
 // ------------------------------------------------------------------------------------------------------------
-void UniversalInterface::setUndefinedState( IOController_i::SensorInfo& si, bool undefined, 
+void UInterface::setUndefinedState( IOController_i::SensorInfo& si, bool undefined,
 											UniSetTypes::ObjectId sup_id )
 {
 	if( si.id == DefaultObjectId )
@@ -217,7 +217,7 @@ void UniversalInterface::setUndefinedState( IOController_i::SensorInfo& si, bool
 			oref = rcache.resolve(si.id, si.node);
 		}
 		catch( NameNotFound ){}
-		
+
 		for (unsigned int i=0; i<uconf->getRepeatCount(); i++)
 		{
 			try
@@ -252,21 +252,21 @@ void UniversalInterface::setUndefinedState( IOController_i::SensorInfo& si, bool
 		rcache.erase(si.id, si.node);
 		// не смогли получить ссылку на объект
 		ulog.warn() << set_err("UI(setUndefinedState): resolve failed",si.id,si.node) << endl;
-	}	
+	}
 	catch(CORBA::NO_IMPLEMENT)
 	{
 		rcache.erase(si.id, si.node);
 		ulog.warn() << set_err("UI(setUndefinedState): method no implement",si.id,si.node) << endl;
-	}	
+	}
 	catch(CORBA::OBJECT_NOT_EXIST)
 	{
 		rcache.erase(si.id, si.node);
 		ulog.warn() << set_err("UI(setUndefinedState): object not exist",si.id,si.node) << endl;
-	}	
+	}
 	catch(CORBA::COMM_FAILURE){}
 	catch(CORBA::SystemException& ex){}
 	catch(...){}
-	
+
 	rcache.erase(si.id, si.node);
 	ulog.warn() << set_err("UI(setUndefinedState): Timeout",si.id,si.node) << endl;
 }
@@ -277,7 +277,7 @@ void UniversalInterface::setUndefinedState( IOController_i::SensorInfo& si, bool
  * \return текущее значение датчика
  * \exception IOBadParam - генерируется если указано неправильное имя вывода или секции
 */
-void UniversalInterface::setValue(ObjectId name, long value, ObjectId node) 
+void UInterface::setValue(ObjectId name, long value, ObjectId node)
 	throw(IO_THROW_EXCEPTIONS)
 {
 	if ( name == DefaultObjectId )
@@ -291,14 +291,14 @@ void UniversalInterface::setValue(ObjectId name, long value, ObjectId node)
 			oref = rcache.resolve(name, node);
 		}
 		catch( NameNotFound ){}
-		
+
 		for (unsigned int i=0; i<uconf->getRepeatCount(); i++)
 		{
 			try
 			{
 				if( CORBA::is_nil(oref) )
 					oref = resolve( name, node );
-			
+
 				IOController_i_var iom = IOController_i::_narrow(oref);
 				IOController_i::SensorInfo_var si;
 				si->id = name;
@@ -329,37 +329,37 @@ void UniversalInterface::setValue(ObjectId name, long value, ObjectId node)
 		rcache.erase(name, node);
 		// не смогли получить ссылку на объект
 		throw UniSetTypes::IOBadParam(set_err("UI(setValue): resolve failed ",name,node));
-	}	
+	}
 	catch(CORBA::NO_IMPLEMENT)
 	{
 		rcache.erase(name, node);
 		throw UniSetTypes::IOBadParam(set_err("UI(setValue): method no implement",name,node));
-	}	
+	}
 	catch(CORBA::OBJECT_NOT_EXIST)
 	{
 		rcache.erase(name, node);
 		throw UniSetTypes::IOBadParam(set_err("UI(setValue): object not exist",name,node));
-	}	
+	}
 	catch(CORBA::COMM_FAILURE& ex)
 	{
 		// ошибка системы коммуникации
-	}	
+	}
 	catch(CORBA::SystemException& ex)
 	{
 		// ошибка системы коммуникации
 		// ulog.warn() << "UI(setValue): CORBA::SystemException" << endl;
-	}	
+	}
 	rcache.erase(name, node);
 	throw UniSetTypes::TimeOut(set_err("UI(setValue): Timeout",name,node));
 }
 
-void UniversalInterface::setValue(ObjectId name, long value) 
+void UInterface::setValue(ObjectId name, long value)
 {
 	setValue(name, value, uconf->getLocalNode());
 }
 
 
-void UniversalInterface::setValue( IOController_i::SensorInfo& si, long value, UniSetTypes::ObjectId supplier )
+void UInterface::setValue( IOController_i::SensorInfo& si, long value, UniSetTypes::ObjectId supplier )
 {
 	ObjectId old = myid;
 	try
@@ -372,13 +372,13 @@ void UniversalInterface::setValue( IOController_i::SensorInfo& si, long value, U
 		myid = old;
 		throw;
 	}
-	
+
 	myid = old;
 }
 
 // ------------------------------------------------------------------------------------------------------------
 // функция не вырабатывает исключий!
-void UniversalInterface::fastSetValue( IOController_i::SensorInfo& si, long value, UniSetTypes::ObjectId sup_id )
+void UInterface::fastSetValue( IOController_i::SensorInfo& si, long value, UniSetTypes::ObjectId sup_id )
 {
 	if ( si.id == DefaultObjectId )
 	{
@@ -397,14 +397,14 @@ void UniversalInterface::fastSetValue( IOController_i::SensorInfo& si, long valu
 			oref = rcache.resolve(si.id, si.node);
 		}
 		catch( NameNotFound ){}
-		
+
 		for (unsigned int i=0; i<uconf->getRepeatCount(); i++)
 		{
 			try
 			{
 				if( CORBA::is_nil(oref) )
 					oref = resolve( si.id,si.node );
-			
+
 				IOController_i_var iom = IOController_i::_narrow(oref);
 				iom->fastSetValue(si, value,sup_id);
 				return;
@@ -412,8 +412,8 @@ void UniversalInterface::fastSetValue( IOController_i::SensorInfo& si, long valu
 			catch(CORBA::TRANSIENT){}
 			catch(CORBA::OBJECT_NOT_EXIST){}
 			catch(CORBA::SystemException& ex){}
-			msleep(uconf->getRepeatTimeout());			
-			oref = CORBA::Object::_nil();			
+			msleep(uconf->getRepeatTimeout());
+			oref = CORBA::Object::_nil();
 		}
 	}
 	catch(UniSetTypes::TimeOut){}
@@ -429,29 +429,29 @@ void UniversalInterface::fastSetValue( IOController_i::SensorInfo& si, long valu
 	}
 	catch(ORepFailed)
 	{
-		rcache.erase(si.id,si.node);	
+		rcache.erase(si.id,si.node);
 		// не смогли получить ссылку на объект
 		ulog.warn() << set_err("UI(fastSetValue): resolve failed ",si.id,si.node) << endl;
-	}	
+	}
 	catch(CORBA::NO_IMPLEMENT)
 	{
 		rcache.erase(si.id,si.node);
 		ulog.warn() << set_err("UI(fastSetValue): method no implement",si.id,si.node) << endl;
-	}	
+	}
 	catch(CORBA::OBJECT_NOT_EXIST)
 	{
 		rcache.erase(si.id,si.node);
 		ulog.warn() << set_err("UI(fastSetValue): object not exist",si.id,si.node) << endl;
-	}	
+	}
 	catch(CORBA::COMM_FAILURE& ex)
 	{
 		// ошибка системы коммуникации
-	}	
+	}
 	catch(CORBA::SystemException& ex)
 	{
 		// ошибка системы коммуникации
 		// ulog.warn() << "UI(setValue): CORBA::SystemException" << endl;
-	}	
+	}
 	catch(...){}
 
 	rcache.erase(si.id,si.node);
@@ -466,12 +466,12 @@ void UniversalInterface::fastSetValue( IOController_i::SensorInfo& si, long valu
  * \param cmd - команда см. \ref UniversalIO::UIOCommand
  * \param backid - обратный адрес (идентификатор заказчика)
 */
-void UniversalInterface::askRemoteSensor( ObjectId name, UniversalIO::UIOCommand cmd, ObjectId node,
+void UInterface::askRemoteSensor( ObjectId name, UniversalIO::UIOCommand cmd, ObjectId node,
 									UniSetTypes::ObjectId backid ) throw(IO_THROW_EXCEPTIONS)
 {
 	if( backid==UniSetTypes::DefaultObjectId )
 		backid = myid;
-		
+
 	if( backid==UniSetTypes::DefaultObjectId )
 		throw UniSetTypes::IOBadParam("UI(askRemoteSensor): unknown back ID");
 
@@ -486,14 +486,14 @@ void UniversalInterface::askRemoteSensor( ObjectId name, UniversalIO::UIOCommand
 			oref = rcache.resolve(name, node);
 		}
 		catch( NameNotFound ){}
-		
+
 		for (unsigned int i=0; i<uconf->getRepeatCount(); i++)
 		{
 			try
 			{
-				if( CORBA::is_nil(oref) )				
+				if( CORBA::is_nil(oref) )
 					oref = resolve( name, node );
-	
+
 				IONotifyController_i_var inc = IONotifyController_i::_narrow(oref);
 				IOController_i::SensorInfo_var si;
 				si->id = name;
@@ -508,8 +508,8 @@ void UniversalInterface::askRemoteSensor( ObjectId name, UniversalIO::UIOCommand
 			catch(CORBA::TRANSIENT){}
 			catch(CORBA::OBJECT_NOT_EXIST){}
 			catch(CORBA::SystemException& ex){}
-			msleep(uconf->getRepeatTimeout());			
-			oref = CORBA::Object::_nil();			
+			msleep(uconf->getRepeatTimeout());
+			oref = CORBA::Object::_nil();
 		}
 	}
 	catch(UniSetTypes::TimeOut){}
@@ -525,36 +525,36 @@ void UniversalInterface::askRemoteSensor( ObjectId name, UniversalIO::UIOCommand
 	}
 	catch(ORepFailed)
 	{
-		rcache.erase(name, node);		
+		rcache.erase(name, node);
 		// не смогли получить ссылку на объект
 		throw UniSetTypes::IOBadParam(set_err("UI(askSensor): resolve failed ",name,node));
-	}	
+	}
 	catch(CORBA::NO_IMPLEMENT)
 	{
-		rcache.erase(name, node);		
+		rcache.erase(name, node);
 		throw UniSetTypes::IOBadParam(set_err("UI(askSensor): method no implement",name,node));
-	}	
+	}
 	catch(CORBA::OBJECT_NOT_EXIST)
 	{
-		rcache.erase(name, node);		
+		rcache.erase(name, node);
 		throw UniSetTypes::IOBadParam(set_err("UI(askSensor): object not exist",name,node));
-	}	
+	}
 	catch(CORBA::COMM_FAILURE& ex)
 	{
 		// ошибка системы коммуникации
 		// ulog.warn() << "UI(askSensor): ошибка системы коммуникации" << endl;
-	}	
+	}
 	catch(CORBA::SystemException& ex)
 	{
 		// ошибка системы коммуникации
 		// ulog.warn() << "UI(askSensor): CORBA::SystemException" << endl;
-	}	
+	}
 
 	rcache.erase(name, node);
 	throw UniSetTypes::TimeOut(set_err("UI(askSensor): Timeout",name,node));
 }
 
-void UniversalInterface::askSensor( ObjectId name, UniversalIO::UIOCommand cmd, UniSetTypes::ObjectId backid )
+void UInterface::askSensor( ObjectId name, UniversalIO::UIOCommand cmd, UniSetTypes::ObjectId backid )
 {
 	askRemoteSensor(name, cmd, uconf->getLocalNode(), backid);
 }
@@ -564,8 +564,8 @@ void UniversalInterface::askSensor( ObjectId name, UniversalIO::UIOCommand cmd,
  * \param name - идентификатор объекта
  * \param node - идентификатор узла
 */
-IOType UniversalInterface::getIOType(ObjectId name, ObjectId node)
-	throw(IO_THROW_EXCEPTIONS)	
+IOType UInterface::getIOType(ObjectId name, ObjectId node)
+	throw(IO_THROW_EXCEPTIONS)
 {
 	if ( name == DefaultObjectId )
 		throw ORepFailed("UI(getIOType): попытка обратиться к объекту с id=UniSetTypes::DefaultObjectId");
@@ -583,7 +583,7 @@ IOType UniversalInterface::getIOType(ObjectId name, ObjectId node)
 		{
 			try
 			{
-				if( CORBA::is_nil(oref) )				
+				if( CORBA::is_nil(oref) )
 					oref = resolve(name, node);
 
 				IOController_i_var inc = IOController_i::_narrow(oref);
@@ -595,13 +595,13 @@ IOType UniversalInterface::getIOType(ObjectId name, ObjectId node)
 			catch(CORBA::TRANSIENT){}
 			catch(CORBA::OBJECT_NOT_EXIST){}
 			catch(CORBA::SystemException& ex){}
-			msleep(uconf->getRepeatTimeout());			
-			oref = CORBA::Object::_nil();			
+			msleep(uconf->getRepeatTimeout());
+			oref = CORBA::Object::_nil();
 		}
 	}
 	catch(IOController_i::NameNotFound& ex)
 	{
-		rcache.erase(name, node);	
+		rcache.erase(name, node);
 		throw UniSetTypes::NameNotFound("UI(getIOType): "+string(ex.err));
 	}
 	catch(IOController_i::IOBadParam& ex)
@@ -611,36 +611,36 @@ IOType UniversalInterface::getIOType(ObjectId name, ObjectId node)
 	}
 	catch(ORepFailed)
 	{
-		rcache.erase(name, node);		
+		rcache.erase(name, node);
 		// не смогли получить ссылку на объект
 		throw UniSetTypes::IOBadParam(set_err("UI(getIOType): resolve failed ",name,node));
-	}	
+	}
 	catch(CORBA::NO_IMPLEMENT)
 	{
-		rcache.erase(name, node);		
+		rcache.erase(name, node);
 		throw UniSetTypes::IOBadParam(set_err("UI(getIOType): method no implement",name,node));
-	}	
+	}
 	catch(CORBA::OBJECT_NOT_EXIST)
 	{
-		rcache.erase(name, node);		
+		rcache.erase(name, node);
 		throw UniSetTypes::IOBadParam(set_err("UI(getIOType): object not exist",name,node));
-	}	
+	}
 	catch(CORBA::COMM_FAILURE& ex)
 	{
 		// ошибка системы коммуникации
 		// ulog.warn() << "UI(getIOType): ошибка системы коммуникации" << endl;
-	}	
+	}
 	catch(CORBA::SystemException& ex)
 	{
 		// ошибка системы коммуникации
 		// ulog.warn() << "UI(getIOType): CORBA::SystemException" << endl;
-	}	
+	}
 
-	rcache.erase(name, node);	
+	rcache.erase(name, node);
 	throw UniSetTypes::TimeOut(set_err("UI(getIOType): Timeout",name, node));
 }
 
-IOType UniversalInterface::getIOType(ObjectId name)
+IOType UInterface::getIOType(ObjectId name)
 {
 	return getIOType(name, uconf->getLocalNode() );
 }
@@ -649,7 +649,7 @@ IOType UniversalInterface::getIOType(ObjectId name)
  * \param name - идентификатор объекта
  * \param node - идентификатор узла
 */
-ObjectType UniversalInterface::getType(ObjectId name, ObjectId node)
+ObjectType UInterface::getType(ObjectId name, ObjectId node)
 	throw(IO_THROW_EXCEPTIONS)
 {
 	if ( name == DefaultObjectId )
@@ -663,12 +663,12 @@ ObjectType UniversalInterface::getType(ObjectId name, ObjectId node)
 			oref = rcache.resolve(name, node);
 		}
 		catch( NameNotFound ){}
-		
+
 		for (unsigned int i=0; i<uconf->getRepeatCount(); i++)
 		{
 			try
 			{
-				if( CORBA::is_nil(oref) )				
+				if( CORBA::is_nil(oref) )
 					oref = resolve( name, node );
 
 				UniSetObject_i_var uo = UniSetObject_i::_narrow(oref);
@@ -677,8 +677,8 @@ ObjectType UniversalInterface::getType(ObjectId name, ObjectId node)
 			catch(CORBA::TRANSIENT){}
 			catch(CORBA::OBJECT_NOT_EXIST){}
 			catch(CORBA::SystemException& ex){}
-			msleep(uconf->getRepeatTimeout());			
-			oref = CORBA::Object::_nil();			
+			msleep(uconf->getRepeatTimeout());
+			oref = CORBA::Object::_nil();
 		}
 	}
 	catch(IOController_i::NameNotFound& ex)
@@ -693,50 +693,50 @@ ObjectType UniversalInterface::getType(ObjectId name, ObjectId node)
 	}
 	catch(ORepFailed)
 	{
-		rcache.erase(name, node);		
+		rcache.erase(name, node);
 		// не смогли получить ссылку на объект
 		throw UniSetTypes::IOBadParam(set_err("UI(getType): resolve failed ",name,node));
-	}	
+	}
 	catch(CORBA::NO_IMPLEMENT)
 	{
-		rcache.erase(name, node);		
+		rcache.erase(name, node);
 		throw UniSetTypes::IOBadParam(set_err("UI(getType): method no implement",name,node));
-	}	
+	}
 	catch(CORBA::OBJECT_NOT_EXIST)
 	{
-		rcache.erase(name, node);		
+		rcache.erase(name, node);
 		throw UniSetTypes::IOBadParam(set_err("UI(getType): object not exist",name,node));
-	}	
+	}
 	catch(CORBA::COMM_FAILURE& ex)
 	{
 		// ошибка системы коммуникации
 		// ulog.warn() << "UI(getType): ошибка системы коммуникации" << endl;
-	}	
+	}
 	catch(CORBA::SystemException& ex)
 	{
 		// ошибка системы коммуникации
 		// ulog.warn() << "UI(getType): CORBA::SystemException" << endl;
-	}	
+	}
 	catch(UniSetTypes::TimeOut){}
-	
-	rcache.erase(name, node);	
+
+	rcache.erase(name, node);
 	throw UniSetTypes::TimeOut(set_err("UI(getType): Timeout",name, node));
 }
 
-ObjectType UniversalInterface::getType(ObjectId name)
+ObjectType UInterface::getType(ObjectId name)
 {
 	return getType(name, uconf->getLocalNode());
 }
 
 // ------------------------------------------------------------------------------------------------------------
-void UniversalInterface::registered(UniSetTypes::ObjectId id, const UniSetTypes::ObjectPtr oRef, bool force)
+void UInterface::registered(UniSetTypes::ObjectId id, const UniSetTypes::ObjectPtr oRef, bool force)
 																					throw(UniSetTypes::ORepFailed)
 {
 	registered(id,uconf->getLocalNode(), oRef,force);
 }
 
 // ------------------------------------------------------------------------------------------------------------
-void UniversalInterface::registered( UniSetTypes::ObjectId id, UniSetTypes::ObjectId node, 
+void UInterface::registered( UniSetTypes::ObjectId id, UniSetTypes::ObjectId node,
 			const UniSetTypes::ObjectPtr oRef, bool force ) throw(ORepFailed)
 {
 	// если влючён режим использования локальных файлов
@@ -761,7 +761,7 @@ void UniversalInterface::registered( UniSetTypes::ObjectId id, UniSetTypes::Obje
 }
 
 // ------------------------------------------------------------------------------------------------------------
-void UniversalInterface::unregister(UniSetTypes::ObjectId id, UniSetTypes::ObjectId node)throw(ORepFailed)
+void UInterface::unregister(UniSetTypes::ObjectId id, UniSetTypes::ObjectId node)throw(ORepFailed)
 {
 	if( uconf->isLocalIOR() )
 	{
@@ -780,13 +780,13 @@ void UniversalInterface::unregister(UniSetTypes::ObjectId id, UniSetTypes::Objec
 }
 
 // ------------------------------------------------------------------------------------------------------------
-void UniversalInterface::unregister(UniSetTypes::ObjectId id)throw(UniSetTypes::ORepFailed)
+void UInterface::unregister(UniSetTypes::ObjectId id)throw(UniSetTypes::ORepFailed)
 {
 	unregister(id,uconf->getLocalNode());
 }
 
 // ------------------------------------------------------------------------------------------------------------
-ObjectPtr UniversalInterface::resolve( ObjectId rid , ObjectId node, int timeoutSec )
+ObjectPtr UInterface::resolve( ObjectId rid , ObjectId node, int timeoutSec )
 	throw(ResolveNameError, UniSetTypes::TimeOut )
 {
 	if ( rid == DefaultObjectId )
@@ -805,7 +805,7 @@ ObjectPtr UniversalInterface::resolve( ObjectId rid , ObjectId node, int timeout
 			if( !sior.empty() )
 			{
 				CORBA::Object_var nso = orb->string_to_object(sior.c_str());
-				rcache.cache(rid, node, nso); // заносим в кэш 
+				rcache.cache(rid, node, nso); // заносим в кэш
 				return nso._retn();
 			}
 			else
@@ -826,7 +826,7 @@ ObjectPtr UniversalInterface::resolve( ObjectId rid , ObjectId node, int timeout
 
 			}
 		}
-	
+
 		if( node!=uconf->getLocalNode() )
 		{
 			// Получаем доступ к NameService на данном узле
@@ -855,9 +855,9 @@ ObjectPtr UniversalInterface::resolve( ObjectId rid , ObjectId node, int timeout
 					ostringstream s;
 					s << bname << curNet;
 					nodeName=s.str();
-				}	
+				}
 			}
-			
+
 			if( CORBA::is_nil(ctx) )
 			{
 				// ulog.warn() << "NameService недоступен на узле "<< node << endl;
@@ -886,21 +886,21 @@ ObjectPtr UniversalInterface::resolve( ObjectId rid , ObjectId node, int timeout
 		CosNaming::Name_var oname = omniURI::stringToName( oind->getNameById(rid,node).c_str() );
 		for (unsigned int i=0; i<uconf->getRepeatCount(); i++)
 		{
-			try		
+			try
 			{
 				CORBA::Object_var nso = ctx->resolve(oname);
 				if( CORBA::is_nil(nso) )
 					throw UniSetTypes::ResolveNameError();
 
 				// Для var
-				rcache.cache(rid, node, nso); // заносим в кэш 
+				rcache.cache(rid, node, nso); // заносим в кэш
 				return nso._retn();
 			}
 			catch(CORBA::TRANSIENT){}
 
 			msleep(uconf->getRepeatTimeout());
 		}
-		
+
 		throw UniSetTypes::TimeOut();
 	}
 	catch(const CosNaming::NamingContext::NotFound &nf){}
@@ -910,46 +910,46 @@ ObjectPtr UniversalInterface::resolve( ObjectId rid , ObjectId node, int timeout
 	catch(CORBA::OBJECT_NOT_EXIST)
 	{
 		throw UniSetTypes::ResolveNameError("ObjectNOTExist");
-	}	
+	}
 	catch(CORBA::COMM_FAILURE& ex)
 	{
 		throw UniSetTypes::ResolveNameError("CORBA::CommFailure");
-	}	
+	}
 	catch(CORBA::SystemException& ex)
 	{
 		// ошибка системы коммуникации
 		// ulog.warn() << "UI(resolve): CORBA::SystemException" << endl;
 		throw UniSetTypes::TimeOut();
-	}	
+	}
 
 	throw UniSetTypes::ResolveNameError();
 }
 
 // -------------------------------------------------------------------------------------------
 
-string UniversalInterface::timeToString(time_t tm, const std::string brk )
+string UInterface::timeToString(time_t tm, const std::string brk )
 {
     struct tm *tms = localtime(&tm);
 	ostringstream time;
 	time << std::setw(2) << std::setfill('0') << tms->tm_hour << brk;
 	time << std::setw(2) << std::setfill('0') << tms->tm_min << brk;
-	time << std::setw(2) << std::setfill('0') << tms->tm_sec;	
+	time << std::setw(2) << std::setfill('0') << tms->tm_sec;
 	return time.str();
 }
 
-string UniversalInterface::dateToString(time_t tm, const std::string brk )
+string UInterface::dateToString(time_t tm, const std::string brk )
 {
     struct tm *tms = localtime(&tm);
 	ostringstream date;
 	date << std::setw(4) << std::setfill('0') << tms->tm_year+1900 << brk;
 	date << std::setw(2) << std::setfill('0') << tms->tm_mon+1 << brk;
-	date << std::setw(2) << std::setfill('0') << tms->tm_mday;	
+	date << std::setw(2) << std::setfill('0') << tms->tm_mday;
 	return date.str();
 }
 
 //--------------------------------------------------------------------------------------------
 
-void UniversalInterface::send( ObjectId name, TransportMessage& msg, ObjectId node) 
+void UInterface::send( ObjectId name, TransportMessage& msg, ObjectId node)
 	throw(IO_THROW_EXCEPTIONS)
 {
 	if ( name == DefaultObjectId )
@@ -986,39 +986,39 @@ void UniversalInterface::send( ObjectId name, TransportMessage& msg, ObjectId no
 	{
 		rcache.erase(name, node);
 		throw UniSetTypes::IOBadParam(set_err("UI(send): resolve failed ",name,node));
-	}	
+	}
 	catch(CORBA::NO_IMPLEMENT)
 	{
 		rcache.erase(name, node);
 		throw UniSetTypes::IOBadParam(set_err("UI(send): method no implement",name,node));
-	}	
+	}
 	catch(CORBA::OBJECT_NOT_EXIST)
 	{
 		rcache.erase(name, node);
 		throw UniSetTypes::IOBadParam(set_err("UI(send): object not exist",name,node));
-	}	
+	}
 	catch(CORBA::COMM_FAILURE& ex)
 	{
 		// ошибка системы коммуникации
 		// ulog.warn() << "UI(send): ошибка системы коммуникации" << endl;
-	}	
+	}
 	catch(CORBA::SystemException& ex)
 	{
 		// ошибка системы коммуникации
 		// ulog.warn() << "UI(send): CORBA::SystemException" << endl;
-	}	
+	}
 
 	rcache.erase(name, node);
 	throw UniSetTypes::TimeOut(set_err("UI(send): Timeout",name, node));
 }
 
-void UniversalInterface::send( ObjectId name, TransportMessage& msg )
+void UInterface::send( ObjectId name, TransportMessage& msg )
 {
 	send(name, msg, uconf->getLocalNode());
 }
 
 // ------------------------------------------------------------------------------------------------------------
-IOController_i::ShortIOInfo UniversalInterface::getChangedTime( UniSetTypes::ObjectId id, UniSetTypes::ObjectId node )
+IOController_i::ShortIOInfo UInterface::getChangedTime( UniSetTypes::ObjectId id, UniSetTypes::ObjectId node )
 {
 	if( id == DefaultObjectId )
 		throw ORepFailed("UI(getChangedTime): Unknown id=UniSetTypes::DefaultObjectId");
@@ -1068,35 +1068,35 @@ IOController_i::ShortIOInfo UniversalInterface::getChangedTime( UniSetTypes::Obj
 	{
 		rcache.erase(si.id, si.node);
 		ulog.warn() << set_err("UI(getChangedTime): resolve failed ",si.id,si.node) << endl;
-	}	
+	}
 	catch(CORBA::NO_IMPLEMENT)
 	{
-		rcache.erase(si.id, si.node);		
+		rcache.erase(si.id, si.node);
 		ulog.warn() << set_err("UI(getChangedTime): method no implement",si.id,si.node) << endl;
-	}	
+	}
 	catch(CORBA::OBJECT_NOT_EXIST)
 	{
 		rcache.erase(si.id, si.node);
 		ulog.warn() << set_err("UI(getChangedTime): object not exist",si.id,si.node) << endl;
-	}	
+	}
 	catch(CORBA::COMM_FAILURE)
 	{
 		// ошибка системы коммуникации
 		// ulog.warn() << "UI(saveState): CORBA::COMM_FAILURE " << endl;
-	}	
+	}
 	catch(CORBA::SystemException& ex)
 	{
 		// ошибка системы коммуникации
 		// ulog.warn() << "UI(saveState): CORBA::SystemException" << endl;
-	}	
+	}
 	catch(...){}
-	
+
 	rcache.erase(si.id, si.node);
 	throw UniSetTypes::TimeOut(set_err("UI(getChangedTime): Timeout",si.id, si.node));
 }
 // ------------------------------------------------------------------------------------------------------------
 
-ObjectPtr UniversalInterface::CacheOfResolve::resolve( ObjectId id, ObjectId node )
+ObjectPtr UInterface::CacheOfResolve::resolve( ObjectId id, ObjectId node )
 	throw(NameNotFound)
 {
 	UniSetTypes::uniset_rwmutex_rlock l(cmutex);
@@ -1109,18 +1109,18 @@ ObjectPtr UniversalInterface::CacheOfResolve::resolve( ObjectId id, ObjectId nod
 		throw UniSetTypes::NameNotFound();
 
 	it->second.timestamp = time(NULL); // фиксируем время последнего обращения
-	
+
 	// т.к. функция возвращает указатель
 	// и тот кто вызывает отвечает за освобождение памяти
 	// то мы делаем _duplicate....
-	
+
 	if( !CORBA::is_nil(it->second.ptr) )
 	    return CORBA::Object::_duplicate(it->second.ptr);
 
 	throw UniSetTypes::NameNotFound();
 }
 // ------------------------------------------------------------------------------------------------------------
-void UniversalInterface::CacheOfResolve::cache( ObjectId id, ObjectId node, ObjectVar ptr )
+void UInterface::CacheOfResolve::cache( ObjectId id, ObjectId node, ObjectVar ptr )
 {
 	UniSetTypes::uniset_rwmutex_wrlock l(cmutex);
 	UniSetTypes::KeyType k(key(id,node));
@@ -1135,7 +1135,7 @@ void UniversalInterface::CacheOfResolve::cache( ObjectId id, ObjectId node, Obje
 	}
 }
 // ------------------------------------------------------------------------------------------------------------
-bool UniversalInterface::CacheOfResolve::clean()
+bool UInterface::CacheOfResolve::clean()
 {
 	UniSetTypes::uniset_rwmutex_wrlock l(cmutex);
 
@@ -1154,12 +1154,12 @@ bool UniversalInterface::CacheOfResolve::clean()
 
 	if( mcache.size() < MaxSize )
 		return true;
-		
+
 	return false;
 }
 // ------------------------------------------------------------------------------------------------------------
 
-void UniversalInterface::CacheOfResolve::erase( UniSetTypes::ObjectId id, UniSetTypes::ObjectId node )
+void UInterface::CacheOfResolve::erase( UniSetTypes::ObjectId id, UniSetTypes::ObjectId node )
 {
 	UniSetTypes::uniset_rwmutex_wrlock l(cmutex);
 //#warning Временно отключён кэш
@@ -1171,7 +1171,7 @@ void UniversalInterface::CacheOfResolve::erase( UniSetTypes::ObjectId id, UniSet
 }
 
 // ------------------------------------------------------------------------------------------------------------
-bool UniversalInterface::isExist( UniSetTypes::ObjectId id )
+bool UInterface::isExist( UniSetTypes::ObjectId id )
 {
 	try
 	{
@@ -1186,10 +1186,10 @@ bool UniversalInterface::isExist( UniSetTypes::ObjectId id )
 				CORBA::Object_var oref = orb->string_to_object(sior.c_str());
 				return rep.isExist( oref );
 			}
-			
+
 			return false;
 		}
-	
+
 		string nm = oind->getNameById(id);
 		return rep.isExist(nm);
 	}
@@ -1201,7 +1201,7 @@ bool UniversalInterface::isExist( UniSetTypes::ObjectId id )
 	return false;
 }
 // ------------------------------------------------------------------------------------------------------------
-bool UniversalInterface::isExist( UniSetTypes::ObjectId id, UniSetTypes::ObjectId node )
+bool UInterface::isExist( UniSetTypes::ObjectId id, UniSetTypes::ObjectId node )
 {
 	if( node==uconf->getLocalNode() )
 		return isExist(id);
@@ -1225,37 +1225,37 @@ bool UniversalInterface::isExist( UniSetTypes::ObjectId id, UniSetTypes::ObjectI
 	return false;
 }
 // --------------------------------------------------------------------------------------------
-string UniversalInterface::set_err(const string& pre, UniSetTypes::ObjectId id, UniSetTypes::ObjectId node)
+string UInterface::set_err(const string& pre, UniSetTypes::ObjectId id, UniSetTypes::ObjectId node)
 {
 	if( id==UniSetTypes::DefaultObjectId )
 		return string(pre+" DefaultObjectId");
 
 	string nm(oind->getNameById(id,node));
-	
+
 	if( nm.empty() )
 		nm = "UnknownName";
 
 	ostringstream s;
-	s << pre << " (" << id << ")" << nm; 
-	return s.str();	
+	s << pre << " (" << id << ")" << nm;
+	return s.str();
 }
 // --------------------------------------------------------------------------------------------
-void UniversalInterface::askThreshold( UniSetTypes::ObjectId sid, UniSetTypes::ThresholdId tid,
+void UInterface::askThreshold( UniSetTypes::ObjectId sid, UniSetTypes::ThresholdId tid,
 										UniversalIO::UIOCommand cmd,
-										CORBA::Long low, CORBA::Long hi, CORBA::Long sb, 
+										CORBA::Long low, CORBA::Long hi, CORBA::Long sb,
 										UniSetTypes::ObjectId backid)
 {
 	askRemoteThreshold(sid, uconf->getLocalNode(), tid, cmd, low,hi,sb, backid);
-}							
+}
 // --------------------------------------------------------------------------------------------
-void UniversalInterface::askRemoteThreshold( UniSetTypes::ObjectId sid, UniSetTypes::ObjectId node,
+void UInterface::askRemoteThreshold( UniSetTypes::ObjectId sid, UniSetTypes::ObjectId node,
 										 UniSetTypes::ThresholdId tid, UniversalIO::UIOCommand cmd,
-										 CORBA::Long lowLimit, CORBA::Long hiLimit, CORBA::Long sensibility, 
+										 CORBA::Long lowLimit, CORBA::Long hiLimit, CORBA::Long sensibility,
 										 UniSetTypes::ObjectId backid )
 {
 	if( backid==UniSetTypes::DefaultObjectId )
 		backid = myid;
-		
+
 	if( backid==UniSetTypes::DefaultObjectId )
 		throw UniSetTypes::IOBadParam("UI(askRemoteThreshold): unknown back ID");
 
@@ -1270,14 +1270,14 @@ void UniversalInterface::askRemoteThreshold( UniSetTypes::ObjectId sid, UniSetTy
 			oref = rcache.resolve(sid, node);
 		}
 		catch( NameNotFound ){}
-		
+
 		for (unsigned int i=0; i<uconf->getRepeatCount(); i++)
 		{
 			try
 			{
-				if( CORBA::is_nil(oref) )				
+				if( CORBA::is_nil(oref) )
 					oref = resolve( sid, node );
-			
+
 				IONotifyController_i_var inc = IONotifyController_i::_narrow(oref);
 				IOController_i::SensorInfo_var si;
 				si->id = sid;
@@ -1293,8 +1293,8 @@ void UniversalInterface::askRemoteThreshold( UniSetTypes::ObjectId sid, UniSetTy
 			catch(CORBA::TRANSIENT){}
 			catch(CORBA::OBJECT_NOT_EXIST){}
 			catch(CORBA::SystemException& ex){}
-			msleep(uconf->getRepeatTimeout());			
-			oref = CORBA::Object::_nil();			
+			msleep(uconf->getRepeatTimeout());
+			oref = CORBA::Object::_nil();
 		}
 	}
 	catch(UniSetTypes::TimeOut){}
@@ -1310,35 +1310,35 @@ void UniversalInterface::askRemoteThreshold( UniSetTypes::ObjectId sid, UniSetTy
 	}
 	catch(ORepFailed)
 	{
-		rcache.erase(sid, node);		
+		rcache.erase(sid, node);
 		throw UniSetTypes::IOBadParam(set_err("UI(askThreshold): resolve failed ",sid,node));
-	}	
+	}
 	catch(CORBA::NO_IMPLEMENT)
 	{
-		rcache.erase(sid, node);		
+		rcache.erase(sid, node);
 		throw UniSetTypes::IOBadParam(set_err("UI(askThreshold): method no implement",sid,node));
-	}	
+	}
 	catch(CORBA::OBJECT_NOT_EXIST)
 	{
-		rcache.erase(sid, node);		
+		rcache.erase(sid, node);
 		throw UniSetTypes::IOBadParam(set_err("UI(askThreshold): object not exist",sid,node));
-	}	
+	}
 	catch(CORBA::COMM_FAILURE& ex)
 	{
 		// ошибка системы коммуникации
 		// ulog.warn() << "UI(askThreshold): ошибка системы коммуникации" << endl;
-	}	
+	}
 	catch(CORBA::SystemException& ex)
 	{
 		// ошибка системы коммуникации
 		// ulog.warn() << "UI(askThreshold): CORBA::SystemException" << endl;
-	}	
-	rcache.erase(sid, node);	
+	}
+	rcache.erase(sid, node);
 	throw UniSetTypes::TimeOut(set_err("UI(askThreshold): Timeout",sid,node));
 
 }
 // --------------------------------------------------------------------------------------------
-CORBA::Long UniversalInterface::getRawValue( const IOController_i::SensorInfo& si )
+CORBA::Long UInterface::getRawValue( const IOController_i::SensorInfo& si )
 {
 	if ( si.id == DefaultObjectId )
 		throw ORepFailed("UI(getRawValue): попытка обратиться к объекту с id=UniSetTypes::DefaultObjectId");
@@ -1382,40 +1382,40 @@ CORBA::Long UniversalInterface::getRawValue( const IOController_i::SensorInfo& s
 	}
 	catch(ORepFailed)
 	{
-		rcache.erase(si.id, si.node);		
+		rcache.erase(si.id, si.node);
 		// не смогли получить ссылку на объект
 		throw UniSetTypes::IOBadParam(set_err("UI(getRawValue): resolve failed ",si.id,si.node));
-	}	
+	}
 	catch(CORBA::NO_IMPLEMENT)
 	{
-		rcache.erase(si.id, si.node);		
+		rcache.erase(si.id, si.node);
 		throw UniSetTypes::IOBadParam(set_err("UI(getRawValue): method no implement",si.id,si.node));
-	}	
+	}
 	catch(CORBA::OBJECT_NOT_EXIST)
 	{
-		rcache.erase(si.id, si.node);		
+		rcache.erase(si.id, si.node);
 		throw UniSetTypes::IOBadParam(set_err("UI(getRawValue): object not exist",si.id,si.node));
-	}	
+	}
 	catch(CORBA::COMM_FAILURE& ex)
 	{
 		// ошибка системы коммуникации
-	}	
+	}
 	catch(CORBA::SystemException& ex)
 	{
 		// ошибка системы коммуникации
 		// ulog.warn() << "UI(getValue): CORBA::SystemException" << endl;
-	}	
-	rcache.erase(si.id, si.node);		
+	}
+	rcache.erase(si.id, si.node);
 	throw UniSetTypes::TimeOut(set_err("UI(getRawValue): Timeout",si.id,si.node));
 }
 // --------------------------------------------------------------------------------------------
-void UniversalInterface::calibrate(const IOController_i::SensorInfo& si, 
+void UInterface::calibrate(const IOController_i::SensorInfo& si,
 								   const IOController_i::CalibrateInfo& ci,
 								   UniSetTypes::ObjectId admId )
 {
 	if( admId==UniSetTypes::DefaultObjectId )
 		admId = myid;
-		
+
 //	if( admId==UniSetTypes::DefaultObjectId )
 //		throw UniSetTypes::IOBadParam("UI(askTreshold): неизвестен ID администратора");
 
@@ -1462,34 +1462,34 @@ void UniversalInterface::calibrate(const IOController_i::SensorInfo& si,
 	}
 	catch(ORepFailed)
 	{
-		rcache.erase(si.id, si.node);		
+		rcache.erase(si.id, si.node);
 		// не смогли получить ссылку на объект
 		throw UniSetTypes::IOBadParam(set_err("UI(calibrate): resolve failed ",si.id,si.node));
-	}	
+	}
 	catch(CORBA::NO_IMPLEMENT)
 	{
-		rcache.erase(si.id, si.node);		
+		rcache.erase(si.id, si.node);
 		throw UniSetTypes::IOBadParam(set_err("UI(calibrate): method no implement",si.id,si.node));
-	}	
+	}
 	catch(CORBA::OBJECT_NOT_EXIST)
 	{
-		rcache.erase(si.id, si.node);		
+		rcache.erase(si.id, si.node);
 		throw UniSetTypes::IOBadParam(set_err("UI(calibrate): object not exist",si.id,si.node));
-	}	
+	}
 	catch(CORBA::COMM_FAILURE& ex)
 	{
 		// ошибка системы коммуникации
-	}	
+	}
 	catch(CORBA::SystemException& ex)
 	{
 		// ошибка системы коммуникации
 		// ulog.warn() << "UI(getValue): CORBA::SystemException" << endl;
-	}	
-	rcache.erase(si.id, si.node);		
+	}
+	rcache.erase(si.id, si.node);
 	throw UniSetTypes::TimeOut(set_err("UI(calibrate): Timeout",si.id,si.node));
-}			   
+}
 // --------------------------------------------------------------------------------------------
-IOController_i::CalibrateInfo UniversalInterface::getCalibrateInfo( const IOController_i::SensorInfo& si )
+IOController_i::CalibrateInfo UInterface::getCalibrateInfo( const IOController_i::SensorInfo& si )
 {
 	if ( si.id == DefaultObjectId )
 		throw ORepFailed("UI(getCalibrateInfo): попытка обратиться к объекту с id=UniSetTypes::DefaultObjectId");
@@ -1533,34 +1533,34 @@ IOController_i::CalibrateInfo UniversalInterface::getCalibrateInfo( const IOCont
 	}
 	catch(ORepFailed)
 	{
-		rcache.erase(si.id, si.node);		
+		rcache.erase(si.id, si.node);
 		// не смогли получить ссылку на объект
 		throw UniSetTypes::IOBadParam(set_err("UI(getCalibrateInfo): resolve failed ",si.id,si.node));
-	}	
+	}
 	catch(CORBA::NO_IMPLEMENT)
 	{
-		rcache.erase(si.id, si.node);		
+		rcache.erase(si.id, si.node);
 		throw UniSetTypes::IOBadParam(set_err("UI(getCalibrateInfo): method no implement",si.id,si.node));
-	}	
+	}
 	catch(CORBA::OBJECT_NOT_EXIST)
 	{
-		rcache.erase(si.id, si.node);		
+		rcache.erase(si.id, si.node);
 		throw UniSetTypes::IOBadParam(set_err("UI(getCalibrateInfo): object not exist",si.id,si.node));
-	}	
+	}
 	catch(CORBA::COMM_FAILURE& ex)
 	{
 		// ошибка системы коммуникации
-	}	
+	}
 	catch(CORBA::SystemException& ex)
 	{
 		// ошибка системы коммуникации
 		// ulog.warn() << "UI(getValue): CORBA::SystemException" << endl;
-	}	
-	rcache.erase(si.id, si.node);		
+	}
+	rcache.erase(si.id, si.node);
 	throw UniSetTypes::TimeOut(set_err("UI(getCalibrateInfo): Timeout",si.id,si.node));
 }
 // --------------------------------------------------------------------------------------------
-IOController_i::SensorInfoSeq_var UniversalInterface::getSensorSeq( UniSetTypes::IDList& lst )
+IOController_i::SensorInfoSeq_var UInterface::getSensorSeq( UniSetTypes::IDList& lst )
 {
 	if( lst.size() == 0 )
 		return IOController_i::SensorInfoSeq_var();
@@ -1587,7 +1587,7 @@ IOController_i::SensorInfoSeq_var UniversalInterface::getSensorSeq( UniSetTypes:
 					oref = resolve(sid,conf->getLocalNode());
 
 				IOController_i_var iom = IOController_i::_narrow(oref);
-				
+
 				UniSetTypes::IDSeq_var seq = lst.getIDSeq();
 				return iom->getSensorSeq(seq);
 			}
@@ -1614,32 +1614,32 @@ IOController_i::SensorInfoSeq_var UniversalInterface::getSensorSeq( UniSetTypes:
 		rcache.erase(sid,conf->getLocalNode());
 		// не смогли получить ссылку на объект
 		throw UniSetTypes::IOBadParam(set_err("UI(getSensorSeq): resolve failed ",sid,conf->getLocalNode()));
-	}	
+	}
 	catch(CORBA::NO_IMPLEMENT)
 	{
 		rcache.erase(sid,conf->getLocalNode());
 		throw UniSetTypes::IOBadParam(set_err("UI(getSensorSeq): method no implement",sid,conf->getLocalNode()));
-	}	
+	}
 	catch(CORBA::OBJECT_NOT_EXIST)
 	{
 		rcache.erase(sid,conf->getLocalNode());
 		throw UniSetTypes::IOBadParam(set_err("UI(getSensorSeq): object not exist",sid,conf->getLocalNode()));
-	}	
+	}
 	catch(CORBA::COMM_FAILURE& ex)
 	{
 		// ошибка системы коммуникации
-	}	
+	}
 	catch(CORBA::SystemException& ex)
 	{
 		// ошибка системы коммуникации
 		// ulog.warn() << "UI(getValue): CORBA::SystemException" << endl;
-	}	
+	}
 	rcache.erase(sid,conf->getLocalNode());
 	throw UniSetTypes::TimeOut(set_err("UI(getSensorSeq): Timeout",sid,conf->getLocalNode()));
 
 }
 // --------------------------------------------------------------------------------------------
-IDSeq_var UniversalInterface::setOutputSeq( const IOController_i::OutSeq& lst, UniSetTypes::ObjectId sup_id )
+IDSeq_var UInterface::setOutputSeq( const IOController_i::OutSeq& lst, UniSetTypes::ObjectId sup_id )
 {
 	if( lst.length() == 0 )
 		return UniSetTypes::IDSeq_var();
@@ -1690,31 +1690,31 @@ IDSeq_var UniversalInterface::setOutputSeq( const IOController_i::OutSeq& lst, U
 		rcache.erase(lst[0].si.id,lst[0].si.node);
 		// не смогли получить ссылку на объект
 		throw UniSetTypes::IOBadParam(set_err("UI(setOutputSeq): resolve failed ",lst[0].si.id,lst[0].si.node));
-	}	
+	}
 	catch(CORBA::NO_IMPLEMENT)
 	{
 		rcache.erase(lst[0].si.id,lst[0].si.node);
 		throw UniSetTypes::IOBadParam(set_err("UI(setOutputSeq): method no implement",lst[0].si.id,lst[0].si.node));
-	}	
+	}
 	catch(CORBA::OBJECT_NOT_EXIST)
 	{
 		rcache.erase(lst[0].si.id,lst[0].si.node);
 		throw UniSetTypes::IOBadParam(set_err("UI(setOutputSeq): object not exist",lst[0].si.id,lst[0].si.node));
-	}	
+	}
 	catch(CORBA::COMM_FAILURE& ex)
 	{
 		// ошибка системы коммуникации
-	}	
+	}
 	catch(CORBA::SystemException& ex)
 	{
 		// ошибка системы коммуникации
 		// ulog.warn() << "UI(getValue): CORBA::SystemException" << endl;
-	}	
+	}
 	rcache.erase(lst[0].si.id,lst[0].si.node);
 	throw UniSetTypes::TimeOut(set_err("UI(setOutputSeq): Timeout",lst[0].si.id,lst[0].si.node));
 }
 // --------------------------------------------------------------------------------------------
-UniSetTypes::IDSeq_var UniversalInterface::askSensorsSeq( UniSetTypes::IDList& lst, 
+UniSetTypes::IDSeq_var UInterface::askSensorsSeq( UniSetTypes::IDList& lst,
 														UniversalIO::UIOCommand cmd, UniSetTypes::ObjectId backid )
 {
 	if( lst.size() == 0 )
@@ -1722,7 +1722,7 @@ UniSetTypes::IDSeq_var UniversalInterface::askSensorsSeq( UniSetTypes::IDList& l
 
 	if( backid==UniSetTypes::DefaultObjectId )
 		backid = myid;
-		
+
 	if( backid==UniSetTypes::DefaultObjectId )
 		throw UniSetTypes::IOBadParam("UI(askSensorSeq): unknown back ID");
 
@@ -1779,31 +1779,31 @@ UniSetTypes::IDSeq_var UniversalInterface::askSensorsSeq( UniSetTypes::IDList& l
 		rcache.erase(sid,conf->getLocalNode());
 		// не смогли получить ссылку на объект
 		throw UniSetTypes::IOBadParam(set_err("UI(askSensorSeq): resolve failed ",sid,conf->getLocalNode()));
-	}	
+	}
 	catch(CORBA::NO_IMPLEMENT)
 	{
 		rcache.erase(sid,conf->getLocalNode());
 		throw UniSetTypes::IOBadParam(set_err("UI(askSensorSeq): method no implement",sid,conf->getLocalNode()));
-	}	
+	}
 	catch(CORBA::OBJECT_NOT_EXIST)
 	{
 		rcache.erase(sid,conf->getLocalNode());
 		throw UniSetTypes::IOBadParam(set_err("UI(askSensorSeq): object not exist",sid,conf->getLocalNode()));
-	}	
+	}
 	catch(CORBA::COMM_FAILURE& ex)
 	{
 		// ошибка системы коммуникации
-	}	
+	}
 	catch(CORBA::SystemException& ex)
 	{
 		// ошибка системы коммуникации
 		// ulog.warn() << "UI(getValue): CORBA::SystemException" << endl;
-	}	
+	}
 	rcache.erase(sid,conf->getLocalNode());
 	throw UniSetTypes::TimeOut(set_err("UI(askSensorSeq): Timeout",sid,conf->getLocalNode()));
 }
 // -----------------------------------------------------------------------------
-IOController_i::ShortMapSeq* UniversalInterface::getSensors( UniSetTypes::ObjectId id, UniSetTypes::ObjectId node )
+IOController_i::ShortMapSeq* UInterface::getSensors( UniSetTypes::ObjectId id, UniSetTypes::ObjectId node )
 {
 	try
 	{
@@ -1847,31 +1847,31 @@ IOController_i::ShortMapSeq* UniversalInterface::getSensors( UniSetTypes::Object
 		rcache.erase(id,node);
 		// не смогли получить ссылку на объект
 		throw UniSetTypes::IOBadParam(set_err("UI(getSensors): resolve failed ",id,node));
-	}	
+	}
 	catch(CORBA::NO_IMPLEMENT)
 	{
 		rcache.erase(id,node);
 		throw UniSetTypes::IOBadParam(set_err("UI(getSensors): method no implement",id,node));
-	}	
+	}
 	catch(CORBA::OBJECT_NOT_EXIST)
 	{
 		rcache.erase(id,node);
 		throw UniSetTypes::IOBadParam(set_err("UI(getSensors): object not exist",id,node));
-	}	
+	}
 	catch(CORBA::COMM_FAILURE& ex)
 	{
 		// ошибка системы коммуникации
-	}	
+	}
 	catch(CORBA::SystemException& ex)
 	{
 		// ошибка системы коммуникации
 		// ulog.warn() << "UI(getValue): CORBA::SystemException" << endl;
-	}	
+	}
 	rcache.erase(id,node);
 	throw UniSetTypes::TimeOut(set_err("UI(getSensors): Timeout",id,node));
 }
 // -----------------------------------------------------------------------------
-bool UniversalInterface::waitReady( UniSetTypes::ObjectId id, int msec, int pmsec, ObjectId node )
+bool UInterface::waitReady( UniSetTypes::ObjectId id, int msec, int pmsec, ObjectId node )
 {
 	PassiveTimer ptReady(msec);
 	bool ready = false;
@@ -1884,14 +1884,14 @@ bool UniversalInterface::waitReady( UniSetTypes::ObjectId id, int msec, int pmse
 				break;
 		}
 		catch(...){}
-	
+
 		msleep(pmsec);
 	}
-	
+
 	return ready;
 }
 // -----------------------------------------------------------------------------
-bool UniversalInterface::waitWorking( UniSetTypes::ObjectId id, int msec, int pmsec, ObjectId node )
+bool UInterface::waitWorking( UniSetTypes::ObjectId id, int msec, int pmsec, ObjectId node )
 {
 	PassiveTimer ptReady(msec);
 	bool ready = false;
@@ -1912,15 +1912,15 @@ bool UniversalInterface::waitWorking( UniSetTypes::ObjectId id, int msec, int pm
 
 }
 // -----------------------------------------------------------------------------
-UniversalIO::IOType UniversalInterface::getConfIOType( UniSetTypes::ObjectId id )
+UniversalIO::IOType UInterface::getConfIOType( UniSetTypes::ObjectId id )
 {
 	if( !conf )
 		return UniversalIO::UnknownIOType;
-		
+
 	xmlNode* x = conf->getXMLObjectNode(id);
 	if( !x )
 		return UniversalIO::UnknownIOType;
-	
+
 	UniXML_iterator it(x);
 	return UniSetTypes::getIOType( it.getProp("iotype") );
 }

src/ObjectRepository/Makefile.am

 noinst_LTLIBRARIES = libObjectsRepository.la
 libObjectsRepository_la_SOURCES = UniSetTypes_iSK.cc UniSetObject_iSK.cc UniSetTypes.cc \
-	ObjectsManager_iSK.cc ObjectIndex.cc ObjectIndex_Array.cc ObjectIndex_XML.cc ObjectIndex_idXML.cc \
-	ORepHelpers.cc UniSetObject.cc ObjectsManager.cc \
-	ObjectsActivator.cc  ObjectRepository.cc ObjectRepositoryFactory.cc \
-	ProxyManager.cc PassiveObject.cc UniSetObject_LT.cc ObjectsManager_LT.cc IORFile.cc
+	UniSetManager_iSK.cc ObjectIndex.cc ObjectIndex_Array.cc ObjectIndex_XML.cc ObjectIndex_idXML.cc \
+	ORepHelpers.cc UniSetObject.cc UniSetManager.cc \
+	UniSetActivator.cc  ObjectRepository.cc ObjectRepositoryFactory.cc \
+	ProxyManager.cc PassiveObject.cc UniSetObject_LT.cc UniSetManager_LT.cc IORFile.cc
 #	ServiceActivator.cc
 
 include $(top_builddir)/conf/setting.mk

src/ObjectRepository/ObjectsActivator.cc → src/ObjectRepository/UniSetActivator.cc

@@ -20,7 +20,7 @@
 /*! \file
  *  \author Pavel Vainerman
 */
-// -------------------------------------------------------------------------- 
+// --------------------------------------------------------------------------
 
 #include <sys/wait.h>
 #include <sys/types.h>
@@ -29,8 +29,8 @@
 
 #include "Exceptions.h"
 #include "ORepHelpers.h"
-#include "UniversalInterface.h"
-#include "ObjectsActivator.h"
+#include "UInterface.h"
+#include "UniSetActivator.h"
 #include "Debug.h"
 #include "Configuration.h"
 
@@ -39,14 +39,14 @@ using namespace UniSetTypes;
 using namespace std;
 // ------------------------------------------------------------------------------------------
 /*
- 	Завершение работы организовано следующим образом.
+	Завершение работы организовано следующим образом.
 	Имеется глобальный указатель gActivator (т.к. активатор в системе должен быть только один).
 	Он заказывает на себя все сигналы связанные с завершением работы.
-	
-	В качестве обработчика сигналов регистрируется ObjectsActivator::terminated( int signo ).
-	В этом обработчике происходит вызов ObjectsActivator::oaDestroy(int signo) для фактического
+
+	В качестве обработчика сигналов регистрируется UniSetActivator::terminated( int signo ).
+	В этом обработчике происходит вызов UniSetActivator::oaDestroy(int signo) для фактического
 	завершения работы и заказывается сигнал SIG_ALRM на время TERMINATE_TIMEOUT,
-	c обработчиком ObjectsActivator::finishterm в котором происходит
+	c обработчиком UniSetActivator::finishterm в котором происходит
 	"надежное" прибивание текущего процесса (raise(SIGKILL)). Это сделано на тот случай, если
 	в oaDestroy произойдет зависание.
 */
@@ -62,10 +62,10 @@ static UniSetTypes::uniset_mutex signalMutex("Activator::signalMutex");
 //static omni_condition pcondx(&pmutex);
 
 // ------------------------------------------------------------------------------------------
-static ObjectsActivator* gActivator=0;
+static UniSetActivator* gActivator=0;
 //static omni_mutex termutex;
 //static omni_condition termcond(&termutex);
-//static ThreadCreator<ObjectsActivator>* termthread=0;
+//static ThreadCreator<UniSetActivator>* termthread=0;
 static int SIGNO;
 static int MYPID;
 static const int TERMINATE_TIMEOUT = 2; //  время отведенное на завершение процесса [сек]
@@ -74,27 +74,27 @@ volatile sig_atomic_t doneterm = 0;
 
 // PassiveTimer termtmr;
 // ------------------------------------------------------------------------------------------
-ObjectsActivator::ObjectsActivator( ObjectId id ):
-ObjectsManager(id),
+UniSetActivator::UniSetActivator( ObjectId id ):
+UniSetManager(id),
 orbthr(0),
 omDestroy(false),
 sig(false)
 {
-	ObjectsActivator::init();
+	UniSetActivator::init();
 }
 // ------------------------------------------------------------------------------------------
-ObjectsActivator::ObjectsActivator():
-ObjectsManager(UniSetTypes::DefaultObjectId),
+UniSetActivator::UniSetActivator():
+UniSetManager(UniSetTypes::DefaultObjectId),
 orbthr(0),
 omDestroy(false),
 sig(false)
 {
 //	thread(false);	//	отключаем поток (раз не задан id)
-	ObjectsActivator::init();
+	UniSetActivator::init();
 }
 
 // ------------------------------------------------------------------------------------------
-void ObjectsActivator::init()
+void UniSetActivator::init()
 {
 	orb = conf->getORB();
 	CORBA::Object_var obj = orb->resolve_initial_references("RootPOA");
@@ -107,13 +107,13 @@ void ObjectsActivator::init()
 		ulog.crit() << myname << "(init): init poa failed!!!" << endl;
 
 	gActivator=this;
-	atexit( ObjectsActivator::normalexit );
-	set_terminate( ObjectsActivator::normalterminate ); // ловушка для неизвестных исключений
+	atexit( UniSetActivator::normalexit );
+	set_terminate( UniSetActivator::normalterminate ); // ловушка для неизвестных исключений
 }
 
 // ------------------------------------------------------------------------------------------
 
-ObjectsActivator::~ObjectsActivator()
+UniSetActivator::~UniSetActivator()
 {
 	if(!procterm )
 	{
@@ -123,8 +123,8 @@ ObjectsActivator::~ObjectsActivator()
 
 		procterm = 1;
 		doneterm = 1;
-		set_signals(false);	
-		gActivator=0;	
+		set_signals(false);
+		gActivator=0;
 	}
 
 	if( orbthr )
@@ -132,7 +132,7 @@ ObjectsActivator::~ObjectsActivator()
 }
 // ------------------------------------------------------------------------------------------
 
-void ObjectsActivator::oaDestroy(int signo)
+void UniSetActivator::oaDestroy(int signo)
 {
 //		waittermMutex.lock();
 		if( !omDestroy )
@@ -145,7 +145,7 @@ void ObjectsActivator::oaDestroy(int signo)
 			ulog.system() << myname << "(oaDestroy): terminate ok. " << endl;
 
 			try
-			{	
+			{
 				stop();
 			}
 			catch(...){}
@@ -175,7 +175,7 @@ void ObjectsActivator::oaDestroy(int signo)
 }
 
 // ------------------------------------------------------------------------------------------
-/*! 
+/*!
  *	Если thread=true то функция создает отдельный поток для обработки приходящих сообщений.
  * 	И передает все ресурсы этого потока orb. А также регистрирует процесс в репозитории.
  *	\note Только после этого объект становится доступен другим процессам
@@ -183,17 +183,17 @@ void ObjectsActivator::oaDestroy(int signo)
  *	Иначе все ресурсы основного потока передаются для обработки приходящих сообщений (и она не выходит)
  *
 */
-void ObjectsActivator::run(bool thread)
+void UniSetActivator::run(bool thread)
 {
 	if( ulog.is_system() )
 		ulog.system() << myname << "(run): создаю менеджер "<< endl;
 
-	ObjectsManager::initPOA(this);
+	UniSetManager::initPOA(this);
 
 	if( getId() == UniSetTypes::DefaultObjectId )
 		offThread(); // отключение потока обработки сообщений, раз не задан ObjectId
-	
-	ObjectsManager::activate(); // а там вызывается активация всех подчиненных объектов и менеджеров
+
+	UniSetManager::activate(); // а там вызывается активация всех подчиненных объектов и менеджеров
 
 	getinfo();		// заполнение информации об объектах
 	active=true;
@@ -202,17 +202,17 @@ void ObjectsActivator::run(bool thread)
 	pman->activate();
 	msleep(50);
 
-	set_signals(true);	
+	set_signals(true);
 	if( thread )
 	{
 		if( ulog.is_info() )
 			ulog.info() << myname << "(run): запускаемся с созданием отдельного потока...  "<< endl;
-		orbthr = new ThreadCreator<ObjectsActivator>(this, &ObjectsActivator::work);
+		orbthr = new ThreadCreator<UniSetActivator>(this, &UniSetActivator::work);
 		if( !orbthr->start() )
 		{
 			ulog.crit() << myname << "(run):  НЕ СМОГЛИ СОЗДАТЬ ORB-поток"<<endl;
-			throw SystemError("(ObjectsActivator::run): CREATE ORB THREAD FAILED");
-		}	
+			throw SystemError("(UniSetActivator::run): CREATE ORB THREAD FAILED");
+		}
 	}
 	else
 	{
@@ -222,17 +222,17 @@ void ObjectsActivator::run(bool thread)
 	}
 }
 // ------------------------------------------------------------------------------------------
-/*! 
+/*!
  *	Функция останавливает работу orb и завершает поток. А так же удаляет ссылку из репозитория.
  *	\note Объект становится недоступен другим процессам
 */
-void ObjectsActivator::stop()
+void UniSetActivator::stop()
 {
 //	uniset_mutex_lock l(disactivateMutex, 500);
 	if( active )
 	{
-		active=false;				
-		
+		active=false;
+
 		if( ulog.is_system() )
 			ulog.system() << myname << "(stop): disactivate...  "<< endl;
 
@@ -263,7 +263,7 @@ void ObjectsActivator::stop()
 
 // ------------------------------------------------------------------------------------------
 
-void ObjectsActivator::work()
+void UniSetActivator::work()
 {
 	if( ulog.is_system() )
 		ulog.system() << myname << "(work): запускаем orb на обработку запросов..."<< endl;
@@ -291,9 +291,9 @@ void ObjectsActivator::work()
 		if( ulog.is_crit() )
 		{
 			ulog.crit() << myname << "(work): : поймали omniORB::fatalException:" << endl;
-     		ulog.crit() << myname << "(work):   file: " << fe.file() << endl;
+			ulog.crit() << myname << "(work):   file: " << fe.file() << endl;
 			ulog.crit() << myname << "(work):   line: " << fe.line() << endl;
-	    	ulog.crit() << myname << "(work):   mesg: " << fe.errmsg() << endl;
+			ulog.crit() << myname << "(work):   mesg: " << fe.errmsg() << endl;
 		}
     }
 	catch(...)
@@ -301,7 +301,7 @@ void ObjectsActivator::work()
 		if( ulog.is_crit() )
 			ulog.crit() << myname << "(work): catch ..." << endl;
 	}
-	
+
 	if( ulog.is_system() )
 		ulog.system() << myname << "(work): orb стоп!!!"<< endl;
 
@@ -313,12 +313,12 @@ void ObjectsActivator::work()
 	}
 	catch(...){}
 	ulog.system() << myname << "(oaDestroy): orb destroy ok."<< endl;
-*/	
+*/
 }
 // ------------------------------------------------------------------------------------------
-void ObjectsActivator::getinfo()
+void UniSetActivator::getinfo()
 {
-	for( ObjectsManagerList::const_iterator it= beginMList();
+	for( UniSetManagerList::const_iterator it= beginMList();
 			it!= endMList(); ++it )
 	{
 		MInfo mi;
@@ -337,7 +337,7 @@ void ObjectsActivator::getinfo()
 	}
 }
 // ------------------------------------------------------------------------------------------
-void ObjectsActivator::processingMessage( UniSetTypes::VoidMessage *msg )
+void UniSetActivator::processingMessage( UniSetTypes::VoidMessage *msg )
 {
 	try
 	{
@@ -352,7 +352,7 @@ void ObjectsActivator::processingMessage( UniSetTypes::VoidMessage *msg )
 
 			default:
 				break;
-		}	
+		}
 	}
 	catch(Exception& ex)
 	{
@@ -362,7 +362,7 @@ void ObjectsActivator::processingMessage( UniSetTypes::VoidMessage *msg )
 
 }
 // -------------------------------------------------------------------------
-void ObjectsActivator::sysCommand( UniSetTypes::SystemMessage *sm )
+void UniSetActivator::sysCommand( UniSetTypes::SystemMessage *sm )
 {
 	switch(sm->command)
 	{
@@ -384,22 +384,22 @@ void ObjectsActivator::sysCommand( UniSetTypes::SystemMessage *sm )
 // -------------------------------------------------------------------------
 
 /*
-void ObjectsActivator::sig_child(int signo)
+void UniSetActivator::sig_child(int signo)
 {
 	ulog.system() << gActivator->getName() << "(sig_child): дочерний процесс закончил работу...(sig=" << signo << ")" << endl;
 	while( waitpid(-1, 0, WNOHANG) > 0);
 }
 */
 // ------------------------------------------------------------------------------------------
-void ObjectsActivator::set_signals(bool ask)
+void UniSetActivator::set_signals(bool ask)
 {
-	
+
 	struct sigaction act, oact;
 	sigemptyset(&act.sa_mask);
 	sigemptyset(&oact.sa_mask);
 
 	// добавляем сигналы, которые будут игнорироваться
-	// при обработке сигнала 
+	// при обработке сигнала
 	sigaddset(&act.sa_mask, SIGINT);
 	sigaddset(&act.sa_mask, SIGTERM);
 	sigaddset(&act.sa_mask, SIGABRT );
@@ -415,7 +415,7 @@ void ObjectsActivator::set_signals(bool ask)
 		act.sa_handler = terminated;
 	else
 		act.sa_handler = SIG_DFL;
-		
+
 	sigaction(SIGINT, &act, &oact);
 	sigaction(SIGTERM, &act, &oact);
 	sigaction(SIGABRT, &act, &oact);
@@ -425,7 +425,7 @@ void ObjectsActivator::set_signals(bool ask)
 }
 
 // ------------------------------------------------------------------------------------------
-void ObjectsActivator::finishterm( int signo )
+void UniSetActivator::finishterm( int signo )
 {
 	if( !doneterm )
 	{
@@ -442,7 +442,7 @@ void ObjectsActivator::finishterm( int signo )
 	}
 }
 // ------------------------------------------------------------------------------------------
-void ObjectsActivator::terminated( int signo )
+void UniSetActivator::terminated( int signo )
 {
 	if( !signo || doneterm || !gActivator || procterm )
 		return;
@@ -453,7 +453,7 @@ void ObjectsActivator::terminated( int signo )
 		uniset_mutex_lock l(signalMutex, TERMINATE_TIMEOUT*1000);
 		if( !procterm )
 		{
-			procterm = 1;			
+			procterm = 1;
 			SIGNO = signo;
 			MYPID = getpid();
 			if( ulog.is_system() && gActivator )
@@ -463,9 +463,9 @@ void ObjectsActivator::terminated( int signo )
 						<< TERMINATE_TIMEOUT << " сек " << endl << flush;
 			}
 			sighold(SIGALRM);
-			sigset(SIGALRM, ObjectsActivator::finishterm);
+			sigset(SIGALRM, UniSetActivator::finishterm);
 			alarm(TERMINATE_TIMEOUT);
-			sigrelse(SIGALRM);				
+			sigrelse(SIGALRM);
 			if( gActivator )
 				gActivator->oaDestroy(SIGNO); // gActivator->term(SIGNO);
 
@@ -473,7 +473,7 @@ void ObjectsActivator::terminated( int signo )
 			if( ulog.is_system() )
 				ulog.system() << gActivator->getName() << "(terminated): завершаемся..."<< endl<< flush;
 			if( gActivator )
-				ObjectsActivator::set_signals(false);
+				UniSetActivator::set_signals(false);
 
 			sigset(SIGALRM, SIG_DFL);
 			raise(SIGNO);
@@ -482,27 +482,27 @@ void ObjectsActivator::terminated( int signo )
 }
 // ------------------------------------------------------------------------------------------
 
-void ObjectsActivator::normalexit()
+void UniSetActivator::normalexit()
 {
 	if( gActivator && ulog.is_system() )
 		ulog.system() << gActivator->getName() << "(default exit): good bye."<< endl << flush;
 }
 
-void ObjectsActivator::normalterminate()
+void UniSetActivator::normalterminate()
 {
 	if( gActivator )
 		ulog.crit() << gActivator->getName() << "(default exception terminate): Никто не выловил исключение!!! Good bye."<< endl<< flush;
 //	abort();
 }
 // ------------------------------------------------------------------------------------------
-void ObjectsActivator::term( int signo )
+void UniSetActivator::term( int signo )
 {
 	if( ulog.is_system() )
 		ulog.system() << myname << "(term): TERM" << endl;
 
 	if( doneterm )
 		return;
-			
+
 	if( signo )
 		sig = true;
 
@@ -511,7 +511,7 @@ void ObjectsActivator::term( int signo )
 		if( ulog.is_system() )
 			ulog.system() << myname << "(term): вызываем sigterm()" << endl;
 		sigterm(signo);
-	
+
 		if( ulog.is_system() )
 			ulog.system() << myname << "(term): sigterm() ok." << endl;
 	}
@@ -525,16 +525,16 @@ void ObjectsActivator::term( int signo )
 		ulog.system() << myname << "(term): END TERM" << endl;
 }
 // ------------------------------------------------------------------------------------------
-void ObjectsActivator::waitDestroy()
+void UniSetActivator::waitDestroy()
 {
 	for(;;)
 	{
 		if( doneterm || !gActivator )
 			break;
-			
+
 		msleep(50);
 	}
-	
+
 	gActivator = 0;
 }
 // ------------------------------------------------------------------------------------------

src/ObjectRepository/ObjectsManager.cc → src/ObjectRepository/UniSetManager.cc

@@ -20,7 +20,7 @@
 /*! \file
  *  \author Pavel Vainerman
 */
-// -------------------------------------------------------------------------- 
+// --------------------------------------------------------------------------
 #include <cstdlib>
 #include <sstream>
 #include <list>
@@ -30,8 +30,8 @@
 
 #include "Exceptions.h"
 #include "ORepHelpers.h"
-#include "UniversalInterface.h"
-#include "ObjectsManager.h"
+#include "UInterface.h"
+#include "UniSetManager.h"
 #include "Debug.h"
 
 // ------------------------------------------------------------------------------------------
@@ -39,11 +39,11 @@ using namespace UniSetTypes;
 using namespace std;
 // ------------------------------------------------------------------------------------------
 // объект-функция для посылки сообщения менеджеру
-class MPush: public unary_function<ObjectsManager*, bool>
+class MPush: public unary_function<UniSetManager*, bool>
 {
-	public: 
+	public:
 		MPush(const UniSetTypes::TransportMessage& msg):msg(msg){}
-		bool operator()(ObjectsManager* m) const
+		bool operator()(UniSetManager* m) const
 		{
 			try
 			{
@@ -54,7 +54,7 @@ class MPush: public unary_function<ObjectsManager*, bool>
 			catch(...){}
 			return false;
 		}
-	
+
 	private:
 		const UniSetTypes::TransportMessage& msg;
 };
@@ -62,7 +62,7 @@ class MPush: public unary_function<ObjectsManager*, bool>
 // объект-функция для посылки сообщения объекту
 class OPush: public unary_function<UniSetObject*, bool>
 {
-	public: 
+	public:
 		OPush(const UniSetTypes::TransportMessage& msg):msg(msg){}
 		bool operator()(UniSetObject* o) const
 		{
@@ -79,7 +79,7 @@ class OPush: public unary_function<UniSetObject*, bool>
 };
 
 // ------------------------------------------------------------------------------------------
-ObjectsManager::ObjectsManager():
+UniSetManager::UniSetManager():
 UniSetObject(UniSetTypes::DefaultObjectId),
 sig(0),
 olistMutex("olistMutex"),
@@ -87,7 +87,7 @@ mlistMutex("mlistMutex")
 {
 }
 // ------------------------------------------------------------------------------------------
-ObjectsManager::ObjectsManager( ObjectId id ):
+UniSetManager::UniSetManager( ObjectId id ):
 UniSetObject(id),
 sig(0)
 {
@@ -97,7 +97,7 @@ sig(0)
 
 // ------------------------------------------------------------------------------------------
 
-ObjectsManager::ObjectsManager(const string& name, const string& section):
+UniSetManager::UniSetManager(const string& name, const string& section):
 UniSetObject(name, section),
 sig(0)
 {
@@ -106,23 +106,23 @@ sig(0)
 }
 
 // ------------------------------------------------------------------------------------------
-ObjectsManager::~ObjectsManager()
+UniSetManager::~UniSetManager()
 {
 	try
 	{
-		objects(deactiv);	
+		objects(deactiv);
 	}
 	catch(...){}
 	try
 	{
-		managers(deactiv);	
+		managers(deactiv);
 	}
 	catch(...){}
 	olist.clear();
 	mlist.clear();
 }
 // ------------------------------------------------------------------------------------------
-void ObjectsManager::initPOA( ObjectsManager* rmngr )
+void UniSetManager::initPOA( UniSetManager* rmngr )
 {
 	if( CORBA::is_nil(pman) )
 		this->pman = rmngr->getPOAManager();
@@ -130,7 +130,7 @@ void ObjectsManager::initPOA( ObjectsManager* rmngr )
 	string mname(getName());
 	mname+="_poamngr";
 	PortableServer::POA_var root_poa = rmngr->getPOA();
-	poa = root_poa->create_POA(mname.c_str(), pman, policyList); 
+	poa = root_poa->create_POA(mname.c_str(), pman, policyList);
 */
 	PortableServer::POA_var rpoa = rmngr->getPOA();
 	if( rpoa != poa )
@@ -141,11 +141,11 @@ void ObjectsManager::initPOA( ObjectsManager* rmngr )
 
 	// Инициализация самого менеджера и его подобъектов
 	UniSetObject::init(rmngr);
-	objects(initial);	
-	managers(initial);	
+	objects(initial);
+	managers(initial);
 }
 // ------------------------------------------------------------------------------------------
-bool ObjectsManager::addObject( UniSetObject *obj )
+bool UniSetManager::addObject( UniSetObject *obj )
 {
 	{	//lock
 		uniset_rwmutex_wrlock lock(olistMutex);
@@ -154,14 +154,14 @@ bool ObjectsManager::addObject( UniSetObject *obj )
 		{
 			if( ulog.is_info() )
 				ulog.info() << myname << "(activator): добавляем объект "<< obj->getName()<< endl;
-		 	olist.push_back(obj);
+			olist.push_back(obj);
 		}
-	} // unlock	
+	} // unlock
 	return true;
 }
 
 // ------------------------------------------------------------------------------------------
-bool ObjectsManager::removeObject(UniSetObject* obj)
+bool UniSetManager::removeObject(UniSetObject* obj)
 {
 	{	//lock
 		uniset_rwmutex_wrlock lock(olistMutex);
@@ -181,39 +181,39 @@ bool ObjectsManager::removeObject(UniSetObject* obj)
 			catch(CORBA::SystemException& ex)
 		    {
 				ulog.warn() << myname << "(removeObject): поймали CORBA::SystemException: " << ex.NP_minorString() << endl;
-	    	}
-	    	catch(CORBA::Exception& ex)
+		}
+		catch(CORBA::Exception& ex)
 		    {
 				ulog.warn() << myname << "(removeObject): CORBA::Exception" << endl;
-    		}
-			catch( omniORB::fatalException& fe ) 
+		}
+			catch( omniORB::fatalException& fe )
 			{
 				ulog.crit() << myname << "(managers): Caught omniORB::fatalException:" << endl;
 			    ulog.crit() << myname << "(managers): file: " << fe.file()
 					<< " line: " << fe.line()
-			    	<< " mesg: " << fe.errmsg() << endl;
-			}			
+				<< " mesg: " << fe.errmsg() << endl;
+			}
 
 			catch(...){}
 			olist.erase(li);
 		}
-	} // unlock	
-	
+	} // unlock
+
 	return true;
 }
 
 // ------------------------------------------------------------------------------------------
-/*! 
+/*!
  *	Функция работы со списком менеджеров
 */
-void ObjectsManager::managers(OManagerCommand cmd)
+void UniSetManager::managers(OManagerCommand cmd)
 {
 	if( ulog.is_info() )
 		ulog.info() << myname <<"(managers): mlist.size="
 						<< mlist.size() << " cmd=" << cmd  << endl;
 	{	//lock
 		uniset_rwmutex_rlock lock(mlistMutex);
-		for( ObjectsManagerList::iterator li=mlist.begin();li!=mlist.end();++li )
+		for( UniSetManagerList::iterator li=mlist.begin();li!=mlist.end();++li )
 		{
 			try
 			{
@@ -257,7 +257,7 @@ void ObjectsManager::managers(OManagerCommand cmd)
 				if( ulog.is_crit() )
 				ulog.crit() << myname << "(managers): Caught CORBA::Exception. " << ex._name() << endl;
 			}
-			catch( omniORB::fatalException& fe ) 
+			catch( omniORB::fatalException& fe )
 			{
 				if( ulog.is_crit() )
 				{
@@ -266,15 +266,15 @@ void ObjectsManager::managers(OManagerCommand cmd)
 						<< " line: " << fe.line()
 					<< " mesg: " << fe.errmsg() << endl;
 				}
-			}			
+			}
 		}
-	} // unlock 
+	} // unlock
 }
 // ------------------------------------------------------------------------------------------
-/*! 
+/*!
  *	Функция работы со списком объектов.
 */
-void ObjectsManager::objects(OManagerCommand cmd)
+void UniSetManager::objects(OManagerCommand cmd)
 {
 	if( ulog.is_info() )
 		ulog.info() << myname <<"(objects): olist.size="
@@ -303,7 +303,7 @@ void ObjectsManager::objects(OManagerCommand cmd)
 					case term:
 						(*li)->sigterm(sig);
 						break;
-					
+
 					default:
 						break;
 				}
@@ -324,11 +324,11 @@ void ObjectsManager::objects(OManagerCommand cmd)
 			catch( CORBA::Exception& ex )
 			{
 				if( ulog.is_crit() )
-				ulog.crit() << myname << "(objects): Caught CORBA::Exception. "
-			    		<< ex._name()
-			    		<< " (" << (*li)->getName() << ")" << endl;
+					ulog.crit() << myname << "(objects): Caught CORBA::Exception. "
+						<< ex._name()
+						<< " (" << (*li)->getName() << ")" << endl;
 			}
-			catch( omniORB::fatalException& fe ) 
+			catch( omniORB::fatalException& fe )
 			{
 				if( ulog.is_crit() )
 				{
@@ -337,16 +337,16 @@ void ObjectsManager::objects(OManagerCommand cmd)
 						<< " line: " << fe.line()
 					<< " mesg: " << fe.errmsg() << endl;
 				}
-			}			
+			}
 		}
 	} // unlock
 }
 // ------------------------------------------------------------------------------------------
-/*! 
+/*!
  *	Регистрирация объекта и всех его подобъектов в репозитории.
  *	\note Только после этого он (и они) становятся доступны другим процессам
 */
-bool ObjectsManager::activateObject()
+bool UniSetManager::activateObject()
 {
 	if( ulog.is_info() )
 		ulog.info() << myname << "(activateObjects):  активизирую объекты"<< endl;
@@ -356,11 +356,11 @@ bool ObjectsManager::activateObject()
 	return true;
 }
 // ------------------------------------------------------------------------------------------
-/*! 
+/*!
  *	Удаление объекта и всех его подобъектов из репозитория.
  *	\note Объект становится недоступен другим процессам
 */
-bool ObjectsManager::disactivateObject()
+bool UniSetManager::disactivateObject()
 {
 	if( ulog.is_info() )
 		ulog.info() << myname << "(disactivateObjects):  деактивизирую объекты"<< endl;
@@ -370,9 +370,9 @@ bool ObjectsManager::disactivateObject()
 	return true;
 }
 // ------------------------------------------------------------------------------------------
-void ObjectsManager::sigterm( int signo )
+void UniSetManager::sigterm( int signo )
 {
-//	ulog.info() << "ObjectsActivator: default processing signo="<< signo << endl;
+//	ulog.info() << "UniSetActivator: default processing signo="<< signo << endl;
 	sig=signo;
 	objects(term);
 	managers(term);
@@ -380,11 +380,11 @@ void ObjectsManager::sigterm( int signo )
 }
 // ------------------------------------------------------------------------------------------
 
-void ObjectsManager::broadcast(const TransportMessage& msg)
+void UniSetManager::broadcast(const TransportMessage& msg)
 {
 	// себя не забыть...
 //	push(msg);
-	
+
 	// Всем объектам...
 	{	//lock
 		uniset_rwmutex_rlock lock(olistMutex);
@@ -399,87 +399,87 @@ void ObjectsManager::broadcast(const TransportMessage& msg)
 }
 
 // ------------------------------------------------------------------------------------------
-bool ObjectsManager::addManager( ObjectsManager *child )
+bool UniSetManager::addManager( UniSetManager *child )
 {
 	{	//lock
 		uniset_rwmutex_wrlock lock(mlistMutex);
 
 		// Проверка на совпадение
-		ObjectsManagerList::iterator it= find(mlist.begin(),mlist.end(),child);
+		UniSetManagerList::iterator it= find(mlist.begin(),mlist.end(),child);
 		if(it == mlist.end() )
 		{
-		 	mlist.push_back( child );
+			mlist.push_back( child );
 			if( ulog.is_info() )
 				ulog.info() << myname << ": добавляем менеджер "<< child->getName()<< endl;
 		}
 		else if( ulog.is_warn() )
 			ulog.warn() << myname << ": попытка повторного добавления объекта "<< child->getName() << endl;
-	} // unlock	
-	
+	} // unlock
+
 	return true;
 }
 
 // ------------------------------------------------------------------------------------------
-bool ObjectsManager::removeManager( ObjectsManager* child )
+bool UniSetManager::removeManager( UniSetManager* child )
 {
 	{	//lock
 		uniset_rwmutex_wrlock lock(mlistMutex);
 		mlist.remove(child);
-	} // unlock	
-	
+	} // unlock
+
 	return true;
 }
 
 // ------------------------------------------------------------------------------------------
 
-const ObjectsManager* ObjectsManager::itemM(const ObjectId id)
+const UniSetManager* UniSetManager::itemM(const ObjectId id)
 {
-	
+
 	{	//lock
 		uniset_rwmutex_rlock lock(mlistMutex);
-		for( ObjectsManagerList::iterator li=mlist.begin(); li!=mlist.end();++li )
+		for( UniSetManagerList::iterator li=mlist.begin(); li!=mlist.end();++li )
 		{
 			if ( (*li)->getId()==id )
-				return (*li);	
+				return (*li);
 		}
-	} // unlock	
+	} // unlock
 
 	return 0;
 }
 
 // ------------------------------------------------------------------------------------------
 
-const UniSetObject* ObjectsManager::itemO(const ObjectId id)
+const UniSetObject* UniSetManager::itemO(const ObjectId id)
 {
 	{	//lock
 		uniset_rwmutex_rlock lock(olistMutex);
 		for (ObjectsList::iterator li=olist.begin(); li!=olist.end();++li)
 		{
 			if ( (*li)->getId()==id )
-				return (*li);	
+				return (*li);
 		}
-	} // unlock	
+	} // unlock
 
 	return 0;
 }
 
 // ------------------------------------------------------------------------------------------
 
-int ObjectsManager::objectsCount()
+int UniSetManager::objectsCount()
 {
 	int res( olist.size()+mlist.size() );
-	
-	for( ObjectsManagerList::const_iterator it= beginMList();
+
+	for( UniSetManagerList::const_iterator it= beginMList();
 			it!= endMList(); ++it )
 	{
 		res+= (*it)->objectsCount();
-	}	
-	
+	}
+
 	return res;
 }
 
 // ------------------------------------------------------------------------------------------
-int ObjectsManager::getObjectsInfo( ObjectsManager* mngr, SimpleInfoSeq* seq, 
+int UniSetManager::getObjectsInfo( UniSetManager* mngr, SimpleInfoSeq* seq,
 									int begin, const long uplimit )
 {
 	int ind = begin;
@@ -487,7 +487,7 @@ int ObjectsManager::getObjectsInfo( ObjectsManager* mngr, SimpleInfoSeq* seq,
 	// получаем у самого менджера
 	SimpleInfo_var msi=mngr->getInfo();
 	(*seq)[ind] = msi;
-	
+
 	ind++;
 	if( ind > uplimit )
 		return ind;
@@ -499,7 +499,7 @@ int ObjectsManager::getObjectsInfo( ObjectsManager* mngr, SimpleInfoSeq* seq,
 		{
 			SimpleInfo_var si=(*it)->getInfo();
 			(*seq)[ind] = si;
-			ind++;				
+			ind++;
 			if( ind>uplimit )
 				break;
 		}
@@ -511,14 +511,14 @@ int ObjectsManager::getObjectsInfo( ObjectsManager* mngr, SimpleInfoSeq* seq,
 		{
 			ulog.warn() << myname << "(getObjectsInfo): не смог получить у объекта "
 					<< conf->oind->getNameById( (*it)->getId() ) << " информацию" << endl;
-		}	
+		}
 	}
 
 	if( ind > uplimit )
 		return ind;
 
 	// а далее у его менеджеров (рекурсивно)
-	for( ObjectsManagerList::const_iterator it=mngr->beginMList();
+	for( UniSetManagerList::const_iterator it=mngr->beginMList();
 		 it!=mngr->endMList(); ++it )
 	{
 		ind = getObjectsInfo((*it),seq,ind,uplimit);
@@ -530,19 +530,19 @@ int ObjectsManager::getObjectsInfo( ObjectsManager* mngr, SimpleInfoSeq* seq,
 }
 // ------------------------------------------------------------------------------------------
 
-SimpleInfoSeq* ObjectsManager::getObjectsInfo( CORBA::Long maxlength )
+SimpleInfoSeq* UniSetManager::getObjectsInfo( CORBA::Long maxlength )
 {
 	SimpleInfoSeq* res = new SimpleInfoSeq();	// ЗА ОСВОБОЖДЕНИЕ ПАМЯТИ ОТВЕЧАЕТ КЛИЕНТ!!!!!!
 												// поэтому ему лучше пользоваться при получении _var-классом
 	int length = objectsCount()+1;
 	if( length >= maxlength )
 		length = maxlength;
-	
+
 	res->length(length);
 
 	// используем рекурсивную функцию
 	int ind = 0;
-	const int limit = length; 
+	const int limit = length;
 	ind = getObjectsInfo( this, res, ind, limit );
 	return res;
 }

src/ObjectRepository/ObjectsManager_LT.cc → src/ObjectRepository/UniSetManager_LT.cc

@@ -20,9 +20,9 @@
 /*! \file
  *  \author Pavel Vainerman
 */
-// -------------------------------------------------------------------------- 
+// --------------------------------------------------------------------------
 #include "Exceptions.h"
-#include "ObjectsManager_LT.h"
+#include "UniSetManager_LT.h"
 #include "Debug.h"
 #include "PassiveTimer.h"
 
@@ -30,30 +30,30 @@
 using namespace std;
 using namespace UniSetTypes;
 // ------------------------------------------------------------------------------------------
-ObjectsManager_LT::ObjectsManager_LT( UniSetTypes::ObjectId id ):
-ObjectsManager(id),
+UniSetManager_LT::UniSetManager_LT( UniSetTypes::ObjectId id ):
+UniSetManager(id),
 sleepTime(UniSetTimer::WaitUpTime)
 {
 }
 // ------------------------------------------------------------------------------------------
-ObjectsManager_LT::ObjectsManager_LT():
-sleepTime(UniSetTimer::WaitUpTime) 
+UniSetManager_LT::UniSetManager_LT():
+sleepTime(UniSetTimer::WaitUpTime)
 {
 }
 
 // ------------------------------------------------------------------------------------------
-ObjectsManager_LT::~ObjectsManager_LT() 
+UniSetManager_LT::~UniSetManager_LT()
 {
 }
 // ------------------------------------------------------------------------------------------
-void ObjectsManager_LT::callback()
+void UniSetManager_LT::callback()
 {
-	// При реализации с использованием waitMessage() каждый раз при вызове askTimer() необходимо 
-	// проверять возвращаемое значение на UniSetTimers::WaitUpTime и вызывать termWaiting(), 
-	// чтобы избежать ситуации, когда процесс до заказа таймера 'спал'(в функции waitMessage()) и после 
+	// При реализации с использованием waitMessage() каждый раз при вызове askTimer() необходимо
+	// проверять возвращаемое значение на UniSetTimers::WaitUpTime и вызывать termWaiting(),
+	// чтобы избежать ситуации, когда процесс до заказа таймера 'спал'(в функции waitMessage()) и после
 	// заказа продолжит спать(т.е. обработчик вызван не будет)...
 	try
-	{	
+	{
 		if( waitMessage(msg, sleepTime) )
 			processingMessage(&msg);
 
@@ -65,7 +65,7 @@ void ObjectsManager_LT::callback()
 	}
 }
 // ------------------------------------------------------------------------------------------
-void ObjectsManager_LT::askTimer( UniSetTypes::TimerId timerid, timeout_t timeMS, short ticks, UniSetTypes::Message::Priority p )
+void UniSetManager_LT::askTimer( UniSetTypes::TimerId timerid, timeout_t timeMS, short ticks, UniSetTypes::Message::Priority p )
 {
 	// проверяйте возвращаемое значение
 	if( lt.askTimer(timerid, timeMS, ticks, p) != UniSetTimer::WaitUpTime )

src/ObjectRepository/UniSetObject.cc

@@ -31,9 +31,9 @@
 #include "Exceptions.h"
 #include "ORepHelpers.h"
 #include "ObjectRepository.h"
-#include "UniversalInterface.h"
+#include "UInterface.h"
 #include "UniSetObject.h"
-#include "ObjectsManager.h"
+#include "UniSetManager.h"
 #include "Debug.h"
 
 // ------------------------------------------------------------------------------------------
@@ -170,7 +170,7 @@ void UniSetObject::init_object()
  *	\param om - указазтель на менджер управляющий объектом
  *	\return Возращает \a true если инициализация прошда успешно, и \a false если нет
 */
-bool UniSetObject::init( ObjectsManager* om )
+bool UniSetObject::init( UniSetManager* om )
 {
 	if( ulog.is_info() )
 	  ulog.info() << myname << ": init..." << endl;
@@ -758,8 +758,8 @@ bool UniSetObject::activate()
 		{
 			ulog.crit() << myname << "(activate): Не задан ID!!! activate failure..." << endl;
 			// вызываем на случай если она переопределена в дочерних классах
-			// Например в ObjectsManager, если здесь не вызвать, то не будут инициализированы подчинённые объекты.
-			// (см. ObjectsManager::activateObject)
+			// Например в UniSetManager, если здесь не вызвать, то не будут инициализированы подчинённые объекты.
+			// (см. UniSetManager::activateObject)
 			activateObject();
 			return false;
 		}

src/Processes/IOController.cc

@@ -24,7 +24,7 @@
 //#include <stream.h>
 #include <sstream>
 #include <cmath>
-#include "UniversalInterface.h"
+#include "UInterface.h"
 #include "IOController.h"
 #include "Debug.h"
 // ------------------------------------------------------------------------------------------
@@ -41,14 +41,14 @@ IOController::IOController():
 // ------------------------------------------------------------------------------------------
 
 IOController::IOController(const string name, const string section):
-	ObjectsManager(name, section),
+	UniSetManager(name, section),
 	ioMutex(name+"_ioMutex"),
 	isPingDBServer(true)
 {
 }
 
 IOController::IOController(ObjectId id):
-	ObjectsManager(id),
+	UniSetManager(id),
 	ioMutex(string(conf->oind->getMapName(id))+"_ioMutex"),
 	isPingDBServer(true)
 {
@@ -62,7 +62,7 @@ IOController::~IOController()
 // ------------------------------------------------------------------------------------------
 bool IOController::activateObject()
 {
-	bool res = ObjectsManager::activateObject();
+	bool res = UniSetManager::activateObject();
 	sensorsRegistration();
 	return res;
 }
@@ -70,7 +70,7 @@ bool IOController::activateObject()
 bool IOController::disactivateObject()
 {
 	sensorsUnregistration();
-	return ObjectsManager::disactivateObject();
+	return UniSetManager::disactivateObject();
 }
 // ------------------------------------------------------------------------------------------
 void IOController::sensorsUnregistration()

src/Processes/IONotifyController.cc

@@ -28,7 +28,7 @@
 #include <stdio.h>
 #include <unistd.h>
 
-#include "UniversalInterface.h"
+#include "UInterface.h"
 #include "IONotifyController.h"
 #include "Debug.h"
 #include "NCRestorer.h"

src/Various/SMonitor.cc

@@ -127,7 +127,7 @@ void SMonitor::sysCommand( SystemMessage *sm )
 // ------------------------------------------------------------------------------------------
 void SMonitor::sensorInfo( SensorMessage *si )
 {
-	cout << "(" << setw(6) << si->id << "): " << setw(8) << UniversalInterface::timeToString(si->sm_tv_sec,":") 
+	cout << "(" << setw(6) << si->id << "): " << setw(8) << UInterface::timeToString(si->sm_tv_sec,":")
 		 << "(" << setw(6) << si->sm_tv_usec << "): ";
 	cout << setw(45) << conf->oind->getMapName(si->id);
 	cout << "\tvalue=" << si->value << "\tfvalue=" << ( (float)si->value / pow(10.0,si->ci.precision) ) << endl;

tests/dlog.cc

+#include <time.h>
+#include "Debug.h"
+#include "UniSetTypes.h"
+
+using namespace std;
+using namespace UniSetTypes;
+
+int main( int argc, const char **argv )
+{
+	DebugStream tlog;
+
+	tlog.addLevel(Debug::ANY);
+
+	tlog[Debug::INFO] << ": [info] ..." << endl;
+	tlog(Debug::INFO) << ": (info) ..." << endl;
+	cout << endl;
+	tlog.d_level1() << ": (level1) ..." << endl;
+	tlog.level1() << ": [level1] ..." << endl;
+	tlog.info() << ": [info] ..." << endl;
+
+	if( tlog.is_level1() )
+		tlog.d_level1() << ": is level1..." << endl;
+
+	return 0;
+}

tests/ui.cc

 #include <time.h>
-#include "UniversalInterface.h"
+#include "UInterface.h"
 #include "UniSetTypes.h"
 
 using namespace std;
@@ -10,7 +10,7 @@ int main( int argc, const char **argv )
 	try
 	{
 		uniset_init(argc,argv,"test.xml");
-		UniversalInterface ui;
+		UInterface ui;
 
 		cout << "** check getSensorID function **" << endl;
 		ObjectId id1 = conf->getSensorID("Input1_S");