ГЛОБАЛЬНЫЙ ПЕРЕХОД НА std::shared_ptr в механизме работы

Utilities/NullController/main.cc

@@ -72,7 +72,7 @@ int main(int argc, char** argv)
 
         NullController nc(ID,askfile,s_field,s_fvalue,c_field,c_fvalue,dbDumping);
         UniSetActivatorPtr act = UniSetActivator::Instance();
-        act->addObject(static_cast<class UniSetObject*>(&nc));
+        act->addObject( nc.get_ptr() );
         act->run(false);
         return 0;
     }

Utilities/SMonit/smonitor.cc

@@ -35,7 +35,7 @@ int main( int argc, const char **argv )
 
         UniSetActivatorPtr act = UniSetActivator::Instance();
         SMonitor tp(ID);
-        act->addObject(&tp);
+        act->addObject(tp.get_ptr());
 
         SystemMessage sm(SystemMessage::StartUp);
         act->broadcast( sm.transport_msg() );

extensions/DBServer-MySQL/main.cc

@@ -52,8 +52,8 @@ int main(int argc, char** argv)
         }
 
         DBServer_MySQL dbs(ID);
-        UniSetActivatorPtr act = UniSetActivator::Instance();
-        act->addObject(static_cast<class UniSetObject*>(&dbs));
+        auto act = UniSetActivator::Instance();
+        act->addObject(dbs.get_ptr());
         act->run(false);
     }
     catch(Exception& ex)

extensions/DBServer-SQLite/main.cc

@@ -53,8 +53,8 @@ int main(int argc, char** argv)
 
         DBServer_SQLite dbs(ID);
 
-        UniSetActivatorPtr act = UniSetActivator::Instance();
-        act->addObject(static_cast<class UniSetObject*>(&dbs));
+        auto act = UniSetActivator::Instance();
+        act->addObject(dbs.get_ptr());
         act->run(false);
     }
     catch(Exception& ex)

extensions/IOControl/IOControl.cc

@@ -23,7 +23,7 @@ std::ostream& operator<<( std::ostream& os, IOControl::IOInfo& inf )
 // -----------------------------------------------------------------------------
 
 IOControl::IOControl( UniSetTypes::ObjectId id, UniSetTypes::ObjectId icID,
-                        SharedMemory* ic, int numcards, const std::string& prefix_ ):
+                        const std::shared_ptr<SharedMemory> ic, int numcards, const std::string& prefix_ ):
     UniSetObject(id),
     polltime(150),
     cards(11),
@@ -1112,8 +1112,8 @@ void IOControl::check_testlamp()
 }
 
 // -----------------------------------------------------------------------------
-IOControl* IOControl::init_iocontrol( int argc, const char* const* argv,
-                                        UniSetTypes::ObjectId icID, SharedMemory* ic,
+std::shared_ptr<IOControl> IOControl::init_iocontrol( int argc, const char* const* argv,
+                                        UniSetTypes::ObjectId icID, const std::shared_ptr<SharedMemory> ic,
                                         const std::string& prefix )
 {
     auto conf = uniset_conf();
@@ -1135,7 +1135,7 @@ IOControl* IOControl::init_iocontrol( int argc, const char* const* argv,
     int numcards = conf->getArgPInt("--"+prefix+"-numcards",1);
 
     dinfo << "(iocontrol): name = " << name << "(" << ID << ")" << endl;
-    return new IOControl(ID,icID,ic,numcards,prefix);
+    return make_shared<IOControl>(ID,icID,ic,numcards,prefix);
 }
 // -----------------------------------------------------------------------------
 void IOControl::help_print( int argc, const char* const* argv )

extensions/IOControl/IOControl.h

@@ -201,12 +201,12 @@ class IOControl:
     public UniSetObject
 {
     public:
-        IOControl( UniSetTypes::ObjectId id, UniSetTypes::ObjectId icID, SharedMemory* ic=0, int numcards=2, const std::string& prefix="io" );
+        IOControl( UniSetTypes::ObjectId id, UniSetTypes::ObjectId icID, const std::shared_ptr<SharedMemory> shm=nullptr, int numcards=2, const std::string& prefix="io" );
         virtual ~IOControl();
 
         /*! глобальная функция для инициализации объекта */
-        static IOControl* init_iocontrol( int argc, const char* const* argv,
-                                            UniSetTypes::ObjectId icID, SharedMemory* ic=0,
+        static std::shared_ptr<IOControl> init_iocontrol( int argc, const char* const* argv,
+                                            UniSetTypes::ObjectId icID, const std::shared_ptr<SharedMemory> ic=nullptr,
                                             const std::string& prefix="io" );
         /*! глобальная функция для вывода help-а */
         static void help_print( int argc, const char* const* argv );

extensions/IOControl/iocontrol.cc

@@ -44,15 +44,15 @@ int main(int argc, const char **argv)
         }
 
 
-        IOControl* ic = IOControl::init_iocontrol(argc,argv,shmID);
+        auto ic = IOControl::init_iocontrol(argc,argv,shmID);
         if( !ic )
         {
             dcrit << "(iocontrol): init не прошёл..." << endl;
             return 1;
         }
 
-        UniSetActivatorPtr act = UniSetActivator::Instance();
-        act->addObject(static_cast<class UniSetObject*>(ic));
+        auto act = UniSetActivator::Instance();
+        act->addObject(ic);
 
         SystemMessage sm(SystemMessage::StartUp);
         act->broadcast( sm.transport_msg() );

extensions/LogicProcessor/PassiveLProcessor.cc

@@ -7,7 +7,7 @@ using namespace UniSetTypes;
 using namespace UniSetExtensions;
 // -------------------------------------------------------------------------
 PassiveLProcessor::PassiveLProcessor( std::string lfile, UniSetTypes::ObjectId objId, 
-                                        UniSetTypes::ObjectId shmID, SharedMemory* ic, const std::string& prefix ):
+                                        UniSetTypes::ObjectId shmID, const std::shared_ptr<SharedMemory> ic, const std::string& prefix ):
     UniSetObject_LT(objId),
     shm(0)
 {

extensions/LogicProcessor/PassiveLProcessor.h

@@ -18,7 +18,7 @@ class PassiveLProcessor:
     public:
 
         PassiveLProcessor( std::string schema, UniSetTypes::ObjectId objId,
-                            UniSetTypes::ObjectId shmID, SharedMemory* ic=0, const std::string& prefix="lproc" );
+                            UniSetTypes::ObjectId shmID, const std::shared_ptr<SharedMemory> ic=nullptr, const std::string& prefix="lproc" );
         virtual ~PassiveLProcessor();
 
         enum Timers

extensions/LogicProcessor/plogicproc.cc

@@ -69,8 +69,8 @@ int main(int argc, const char **argv)
 
         PassiveLProcessor plc(schema,ID,shmID);
 
-        UniSetActivatorPtr act = UniSetActivator::Instance();
-        act->addObject(static_cast<class UniSetObject*>(&plc));
+        auto act = UniSetActivator::Instance();
+        act->addObject(plc.get_ptr());
 
         SystemMessage sm(SystemMessage::StartUp);
         act->broadcast( sm.transport_msg() );

extensions/ModbusMaster/MBExchange.cc

@@ -12,7 +12,7 @@ using namespace UniSetTypes;
 using namespace UniSetExtensions;
 // -----------------------------------------------------------------------------
 MBExchange::MBExchange( UniSetTypes::ObjectId objId, UniSetTypes::ObjectId shmId, 
-                            SharedMemory* ic, const std::string& prefix ):
+                            const std::shared_ptr<SharedMemory> ic, const std::string& prefix ):
 UniSetObject_LT(objId),
 allInitOK(false),
 shm(0),

extensions/ModbusMaster/MBExchange.h

@@ -28,7 +28,7 @@ class MBExchange:
     public UniSetObject_LT
 {
     public:
-        MBExchange( UniSetTypes::ObjectId objId, UniSetTypes::ObjectId shmID, SharedMemory* ic=0,
+        MBExchange( UniSetTypes::ObjectId objId, UniSetTypes::ObjectId shmID, const std::shared_ptr<SharedMemory> ic=nullptr,
                         const std::string& prefix="mb" );
         virtual ~MBExchange();
 

extensions/ModbusMaster/MBTCPMaster.cc

@@ -11,7 +11,7 @@ using namespace UniSetTypes;
 using namespace UniSetExtensions;
 // -----------------------------------------------------------------------------
 MBTCPMaster::MBTCPMaster( UniSetTypes::ObjectId objId, UniSetTypes::ObjectId shmId, 
-                            SharedMemory* ic, const std::string& prefix ):
+                          const std::shared_ptr<SharedMemory> ic, const std::string& prefix ):
 MBExchange(objId,shmId,ic,prefix),
 force_disconnect(true),
 mbtcp(nullptr),
@@ -217,8 +217,8 @@ void MBTCPMaster::help_print( int argc, const char* const* argv )
     cout << "--prefix-persistent-connection 0,1     - Не закрывать соединение на каждом цикле опроса" << endl;
 }
 // -----------------------------------------------------------------------------
-MBTCPMaster* MBTCPMaster::init_mbmaster( int argc, const char* const* argv, 
-                                            UniSetTypes::ObjectId icID, SharedMemory* ic,
+std::shared_ptr<MBTCPMaster> MBTCPMaster::init_mbmaster( int argc, const char* const* argv,
+                                            UniSetTypes::ObjectId icID, const std::shared_ptr<SharedMemory> ic,
                                             const std::string& prefix )
 {
     auto conf = uniset_conf();
@@ -239,6 +239,6 @@ MBTCPMaster* MBTCPMaster::init_mbmaster( int argc, const char* const* argv,
     }
 
     dinfo << "(MBTCPMaster): name = " << name << "(" << ID << ")" << endl;
-    return new MBTCPMaster(ID,icID,ic,prefix);
+    return make_shared<MBTCPMaster>(ID,icID,ic,prefix);
 }
 // -----------------------------------------------------------------------------

extensions/ModbusMaster/MBTCPMaster.h

@@ -193,13 +193,13 @@ class MBTCPMaster:
     public MBExchange
 {
     public:
-        MBTCPMaster( UniSetTypes::ObjectId objId, UniSetTypes::ObjectId shmID, SharedMemory* ic=0,
+        MBTCPMaster( UniSetTypes::ObjectId objId, UniSetTypes::ObjectId shmID, const std::shared_ptr<SharedMemory> ic=nullptr,
                         const std::string& prefix="mbtcp" );
         virtual ~MBTCPMaster();
 
         /*! глобальная функция для инициализации объекта */
-        static MBTCPMaster* init_mbmaster( int argc, const char* const* argv,
-                                            UniSetTypes::ObjectId shmID, SharedMemory* ic=0,
+        static std::shared_ptr<MBTCPMaster> init_mbmaster( int argc, const char* const* argv,
+                                            UniSetTypes::ObjectId shmID, const std::shared_ptr<SharedMemory> ic=nullptr,
                                             const std::string& prefix="mbtcp" );
 
         /*! глобальная функция для вывода help-а */

extensions/ModbusMaster/MBTCPMultiMaster.cc

@@ -11,7 +11,7 @@ using namespace UniSetTypes;
 using namespace UniSetExtensions;
 // -----------------------------------------------------------------------------
 MBTCPMultiMaster::MBTCPMultiMaster( UniSetTypes::ObjectId objId, UniSetTypes::ObjectId shmId, 
-                            SharedMemory* ic, const std::string& prefix ):
+                            const std::shared_ptr<SharedMemory> ic, const std::string& prefix ):
 MBExchange(objId,shmId,ic,prefix),
 force_disconnect(true),
 pollThread(0),
@@ -363,8 +363,8 @@ void MBTCPMultiMaster::help_print( int argc, const char* const* argv )
     cout << " Переключение на следующий канал зависит от '--prefix-timeout'" << endl;
 }
 // -----------------------------------------------------------------------------
-MBTCPMultiMaster* MBTCPMultiMaster::init_mbmaster( int argc, const char* const* argv, 
-                                            UniSetTypes::ObjectId icID, SharedMemory* ic,
+std::shared_ptr<MBTCPMultiMaster> MBTCPMultiMaster::init_mbmaster( int argc, const char* const* argv,
+                                            UniSetTypes::ObjectId icID, const std::shared_ptr<SharedMemory> ic,
                                             const std::string& prefix )
 {
     auto conf = uniset_conf();
@@ -386,6 +386,6 @@ MBTCPMultiMaster* MBTCPMultiMaster::init_mbmaster( int argc, const char* const*
     }
 
     dinfo << "(MBTCPMultiMaster): name = " << name << "(" << ID << ")" << endl;
-    return new MBTCPMultiMaster(ID,icID,ic,prefix);
+    return make_shared<MBTCPMultiMaster>(ID,icID,ic,prefix);
 }
 // -----------------------------------------------------------------------------

extensions/ModbusMaster/MBTCPMultiMaster.h

@@ -214,13 +214,13 @@ class MBTCPMultiMaster:
     public MBExchange
 {
     public:
-        MBTCPMultiMaster( UniSetTypes::ObjectId objId, UniSetTypes::ObjectId shmID, SharedMemory* ic=0,
+        MBTCPMultiMaster( UniSetTypes::ObjectId objId, UniSetTypes::ObjectId shmID, const std::shared_ptr<SharedMemory> ic=nullptr,
                         const std::string& prefix="mbtcp" );
         virtual ~MBTCPMultiMaster();
 
         /*! глобальная функция для инициализации объекта */
-        static MBTCPMultiMaster* init_mbmaster( int argc, const char* const* argv,
-                                            UniSetTypes::ObjectId shmID, SharedMemory* ic=0,
+        static std::shared_ptr<MBTCPMultiMaster> init_mbmaster( int argc, const char* const* argv,
+                                            UniSetTypes::ObjectId shmID, const std::shared_ptr<SharedMemory> ic=nullptr,
                                             const std::string& prefix="mbtcp" );
 
         /*! глобальная функция для вывода help-а */

extensions/ModbusMaster/RTUExchange.cc

@@ -8,7 +8,7 @@ using namespace std;
 using namespace UniSetTypes;
 using namespace UniSetExtensions;
 // -----------------------------------------------------------------------------
-RTUExchange::RTUExchange( UniSetTypes::ObjectId objId, UniSetTypes::ObjectId shmId, SharedMemory* ic,
+RTUExchange::RTUExchange( UniSetTypes::ObjectId objId, UniSetTypes::ObjectId shmId, const std::shared_ptr<SharedMemory> ic,
                           const std::string& prefix_ ):
 MBExchange(objId,shmId,ic,prefix_),
 mbrtu(0),
@@ -316,8 +316,8 @@ void RTUExchange::poll()
 //    printMap(rmap);
 }
 // -----------------------------------------------------------------------------
-RTUExchange* RTUExchange::init_rtuexchange( int argc, const char* const* argv, UniSetTypes::ObjectId icID,
-                                            SharedMemory* ic, const std::string& prefix )
+std::shared_ptr<RTUExchange> RTUExchange::init_rtuexchange( int argc, const char* const* argv, UniSetTypes::ObjectId icID,
+                                            const std::shared_ptr<SharedMemory> ic, const std::string& prefix )
 {
     auto conf = uniset_conf();
 
@@ -338,7 +338,7 @@ RTUExchange* RTUExchange::init_rtuexchange( int argc, const char* const* argv, U
     }
 
     dinfo << "(rtuexchange): name = " << name << "(" << ID << ")" << endl;
-    return new RTUExchange(ID,icID,ic,prefix);
+    return make_shared<RTUExchange>(ID,icID,ic,prefix);
 }
 // -----------------------------------------------------------------------------
 bool RTUExchange::initDeviceInfo( RTUDeviceMap& m, ModbusRTU::ModbusAddr a, UniXML::iterator& it )

extensions/ModbusMaster/RTUExchange.h

@@ -14,12 +14,12 @@ class RTUExchange:
 {
     public:
         RTUExchange( UniSetTypes::ObjectId objId, UniSetTypes::ObjectId shmID,
-                      SharedMemory* ic=0, const std::string& prefix="rs" );
+                      const std::shared_ptr<SharedMemory> ic=nullptr, const std::string& prefix="rs" );
         virtual ~RTUExchange();
 
         /*! глобальная функция для инициализации объекта */
-        static RTUExchange* init_rtuexchange( int argc, const char* const* argv,
-                                            UniSetTypes::ObjectId shmID, SharedMemory* ic=0,
+        static std::shared_ptr<RTUExchange> init_rtuexchange( int argc, const char* const* argv,
+                                            UniSetTypes::ObjectId shmID, const std::shared_ptr<SharedMemory> ic=nullptr,
                                             const std::string& prefix="rs" );
 
         /*! глобальная функция для вывода help-а */

extensions/ModbusMaster/main.cc

@@ -50,15 +50,15 @@ int main( int argc, const char** argv )
             return 1;
         }
 
-        MBTCPMaster* mb = MBTCPMaster::init_mbmaster(argc,argv,shmID);
+        auto mb = MBTCPMaster::init_mbmaster(argc,argv,shmID);
         if( !mb )
         {
             dcrit << "(mbmaster): init MBTCPMaster failed." << endl;
             return 1;
         }
 
-        UniSetActivatorPtr act = UniSetActivator::Instance();
-        act->addObject(static_cast<class UniSetObject*>(mb));
+        auto act = UniSetActivator::Instance();
+        act->addObject(mb);
 
         SystemMessage sm(SystemMessage::StartUp);
         act->broadcast( sm.transport_msg() );

extensions/ModbusMaster/multi-main.cc

@@ -50,15 +50,15 @@ int main( int argc, const char** argv )
             return 1;
         }
 
-        MBTCPMultiMaster* mb = MBTCPMultiMaster::init_mbmaster(argc,argv,shmID);
+        auto mb = MBTCPMultiMaster::init_mbmaster(argc,argv,shmID);
         if( !mb )
         {
             dcrit << "(mbmaster): init MBTCPMaster failed." << endl;
             return 1;
         }
 
-        UniSetActivatorPtr act = UniSetActivator::Instance();
-        act->addObject(static_cast<class UniSetObject*>(mb));
+        auto act = UniSetActivator::Instance();
+        act->addObject(mb);
 
         SystemMessage sm(SystemMessage::StartUp);
         act->broadcast( sm.transport_msg() );

extensions/ModbusMaster/rtuexchange.cc

@@ -48,15 +48,15 @@ int main( int argc, char** argv )
             return 1;
         }
 
-        RTUExchange* rs = RTUExchange::init_rtuexchange(argc,argv,shmID,0,"rs");
+        auto rs = RTUExchange::init_rtuexchange(argc,argv,shmID,0,"rs");
         if( !rs )
         {
             dcrit << "(rtuexchange): init не прошёл..." << endl;
             return 1;
         }
 
-        UniSetActivatorPtr act = UniSetActivator::Instance();
-        act->addObject(static_cast<class UniSetObject*>(rs));
+        auto act = UniSetActivator::Instance();
+        act->addObject(rs);
 
         SystemMessage sm(SystemMessage::StartUp);
         act->broadcast( sm.transport_msg() );

extensions/ModbusSlave/MBSlave.cc

@@ -11,7 +11,7 @@ using namespace UniSetTypes;
 using namespace UniSetExtensions;
 using namespace ModbusRTU;
 // -----------------------------------------------------------------------------
-MBSlave::MBSlave( UniSetTypes::ObjectId objId, UniSetTypes::ObjectId shmId, SharedMemory* ic, const string& prefix ):
+MBSlave::MBSlave( UniSetTypes::ObjectId objId, UniSetTypes::ObjectId shmId, const std::shared_ptr<SharedMemory> ic, const string& prefix ):
 UniSetObject_LT(objId),
 mbslot(0),
 shm(0),
@@ -934,8 +934,8 @@ void MBSlave::help_print( int argc, const char* const* argv )
     cout << "--prefix-inet-port num - this modbus server port. Default: 502" << endl;
 }
 // -----------------------------------------------------------------------------
-MBSlave* MBSlave::init_mbslave( int argc, const char* const* argv, UniSetTypes::ObjectId icID, SharedMemory* ic,
-                                const string& prefix )
+std::shared_ptr<MBSlave> MBSlave::init_mbslave( int argc, const char* const* argv, UniSetTypes::ObjectId icID,
+                                                const std::shared_ptr<SharedMemory> ic, const string& prefix )
 {
     auto conf = uniset_conf();
     string name = conf->getArgParam("--" + prefix + "-name","MBSlave1");
@@ -955,7 +955,7 @@ MBSlave* MBSlave::init_mbslave( int argc, const char* const* argv, UniSetTypes::
     }
 
     dinfo << "(mbslave): name = " << name << "(" << ID << ")" << endl;
-    return new MBSlave(ID,icID,ic,prefix);
+    return make_shared<MBSlave>(ID,icID,ic,prefix);
 }
 // -----------------------------------------------------------------------------
 std::ostream& operator<<( std::ostream& os, MBSlave::IOProperty& p )

extensions/ModbusSlave/MBSlave.h

@@ -257,12 +257,12 @@ class MBSlave:
     public UniSetObject_LT
 {
     public:
-        MBSlave( UniSetTypes::ObjectId objId, UniSetTypes::ObjectId shmID, SharedMemory* ic=0, const std::string& prefix="mbs" );
+        MBSlave( UniSetTypes::ObjectId objId, UniSetTypes::ObjectId shmID, const std::shared_ptr<SharedMemory> ic=nullptr, const std::string& prefix="mbs" );
         virtual ~MBSlave();
 
         /*! глобальная функция для инициализации объекта */
-        static MBSlave* init_mbslave( int argc, const char* const* argv,
-                                      UniSetTypes::ObjectId shmID, SharedMemory* ic=0,
+        static std::shared_ptr<MBSlave> init_mbslave(int argc, const char* const* argv,
+                                      UniSetTypes::ObjectId shmID, const std::shared_ptr<SharedMemory> ic=nullptr,
                                       const std::string& prefix="mbs" );
 
         /*! глобальная функция для вывода help-а */

extensions/ModbusSlave/MBTCPMultiSlave.cc

@@ -11,7 +11,7 @@ using namespace UniSetTypes;
 using namespace UniSetExtensions;
 using namespace ModbusRTU;
 // -----------------------------------------------------------------------------
-MBTCPMultiSlave::MBTCPMultiSlave( UniSetTypes::ObjectId objId, UniSetTypes::ObjectId shmId, SharedMemory* ic, const string& prefix ):
+MBTCPMultiSlave::MBTCPMultiSlave( UniSetTypes::ObjectId objId, UniSetTypes::ObjectId shmId, const std::shared_ptr<SharedMemory> ic, const string& prefix ):
 MBSlave(objId,shmId,ic,prefix),
 sesscount_id(DefaultObjectId)
 {
@@ -110,8 +110,8 @@ void MBTCPMultiSlave::help_print( int argc, const char* const* argv )
    cout << "--prefix-session-count-id  id - Датчик для отслеживания текущего количества соединений." << endl;
 }
 // -----------------------------------------------------------------------------
-MBTCPMultiSlave* MBTCPMultiSlave::init_mbslave( int argc, const char* const* argv, UniSetTypes::ObjectId icID, SharedMemory* ic,
-                                const string& prefix )
+std::shared_ptr<MBTCPMultiSlave> MBTCPMultiSlave::init_mbslave( int argc, const char* const* argv, UniSetTypes::ObjectId icID,
+                                                                const std::shared_ptr<SharedMemory> ic, const string& prefix )
 {
     auto conf = uniset_conf();
     string name = conf->getArgParam("--" + prefix + "-name","MBSlave1");
@@ -131,7 +131,7 @@ MBTCPMultiSlave* MBTCPMultiSlave::init_mbslave( int argc, const char* const* arg
     }
 
     dinfo << "(mbslave): name = " << name << "(" << ID << ")" << endl;
-    return new MBTCPMultiSlave(ID,icID,ic,prefix);
+    return make_shared<MBTCPMultiSlave>(ID,icID,ic,prefix);
 }
 // -----------------------------------------------------------------------------
 void MBTCPMultiSlave::execute_tcp()

extensions/ModbusSlave/MBTCPMultiSlave.h

@@ -21,12 +21,12 @@ class MBTCPMultiSlave:
     public MBSlave
 {
     public:
-        MBTCPMultiSlave( UniSetTypes::ObjectId objId, UniSetTypes::ObjectId shmID, SharedMemory* ic=0, const std::string& prefix="mbs" );
+        MBTCPMultiSlave( UniSetTypes::ObjectId objId, UniSetTypes::ObjectId shmID, const std::shared_ptr<SharedMemory> ic=nullptr, const std::string& prefix="mbs" );
         virtual ~MBTCPMultiSlave();
 
         /*! глобальная функция для инициализации объекта */
-        static MBTCPMultiSlave* init_mbslave( int argc, const char* const* argv,
-                                            UniSetTypes::ObjectId shmID, SharedMemory* ic=0,
+        static std::shared_ptr<MBTCPMultiSlave> init_mbslave( int argc, const char* const* argv,
+                                            UniSetTypes::ObjectId shmID, const std::shared_ptr<SharedMemory> ic=nullptr,
                                             const std::string& prefix="mbs" );
 
         /*! глобальная функция для вывода help-а */

extensions/ModbusSlave/mbslave.cc

@@ -55,15 +55,15 @@ int main(int argc, const char **argv)
             return 1;
         }
 
-        MBSlave* s = MBSlave::init_mbslave(argc,argv,shmID);
+        auto s = MBSlave::init_mbslave(argc,argv,shmID);
         if( !s )
         {
             dcrit << "(mbslave): init не прошёл..." << endl;
             return 1;
         }
 
-        UniSetActivatorPtr act = UniSetActivator::Instance();
-        act->addObject(static_cast<class UniSetObject*>(s));
+        auto act = UniSetActivator::Instance();
+        act->addObject(s);
         SystemMessage sm(SystemMessage::StartUp);
         act->broadcast( sm.transport_msg() );
 

extensions/ModbusSlave/mbtcp-multislave.cc

@@ -55,15 +55,15 @@ int main(int argc, const char **argv)
             return 1;
         }
 
-        MBTCPMultiSlave* s = MBTCPMultiSlave::init_mbslave(argc,argv,shmID);
+        auto s = MBTCPMultiSlave::init_mbslave(argc,argv,shmID);
         if( !s )
         {
             dcrit << "(mbslave): init не прошёл..." << endl;
             return 1;
         }
 
-        UniSetActivatorPtr act = UniSetActivator::Instance();
-        act->addObject(static_cast<class UniSetObject*>(s));
+        auto act = UniSetActivator::Instance();
+        act->addObject(s);
         SystemMessage sm(SystemMessage::StartUp);
         act->broadcast( sm.transport_msg() );
 

extensions/ModbusSlave/tests/tests_with_sm.cc

@@ -36,18 +36,18 @@ int main(int argc, char* argv[] )
 
         bool apart = findArgParam("--apart",argc,argv) != -1;
 
-        SharedMemory* shm = SharedMemory::init_smemory(argc, argv);
+        auto shm = SharedMemory::init_smemory(argc, argv);
         if( !shm )
             return 1;
 
-        MBSlave* mbs = MBSlave::init_mbslave(argc,argv,shm->getId(), (apart ? nullptr : shm ));
+        auto mbs = MBSlave::init_mbslave(argc,argv,shm->getId(), (apart ? nullptr : shm ));
         if( !mbs )
             return 1;
 
-        UniSetActivatorPtr act = UniSetActivator::Instance();
+        auto act = UniSetActivator::Instance();
 
-        act->addObject(static_cast<class UniSetObject*>(shm));
-        act->addObject(static_cast<class UniSetObject*>(mbs));
+        act->addObject(shm);
+        act->addObject(mbs);
 
         SystemMessage sm(SystemMessage::StartUp);
         act->broadcast( sm.transport_msg() );

extensions/RRDServer/RRDServer.cc

@@ -11,12 +11,12 @@ using namespace std;
 using namespace UniSetTypes;
 using namespace UniSetExtensions;
 // -----------------------------------------------------------------------------
-RRDServer::RRDServer( UniSetTypes::ObjectId objId, xmlNode* cnode, UniSetTypes::ObjectId shmId, SharedMemory* ic,
+RRDServer::RRDServer( UniSetTypes::ObjectId objId, xmlNode* cnode, UniSetTypes::ObjectId shmId, const std::shared_ptr<SharedMemory> ic,
             const string& prefix, DebugStream& log ):
 UObject_SK(objId,cnode),
-shm( new SMInterface(shmId,&ui,objId,ic) ),
 prefix(prefix)
 {
+    shm = make_shared<SMInterface>(shmId,&ui,objId,ic);
     mylog = log;
     UniXML::iterator it(cnode);
 
@@ -222,8 +222,8 @@ void RRDServer::help_print( int argc, const char* const* argv )
     cout << "--prefix-heartbeat-max val   - max value for heartbeat sensor." << endl;
 }
 // -----------------------------------------------------------------------------
-RRDServer* RRDServer::init_rrdstorage( int argc, const char* const* argv, 
-                                            UniSetTypes::ObjectId icID, SharedMemory* ic,
+std::shared_ptr<RRDServer> RRDServer::init_rrdstorage( int argc, const char* const* argv,
+                                            UniSetTypes::ObjectId icID, const std::shared_ptr<SharedMemory> ic,
                                             const std::string& prefix )
 {
     auto conf = uniset_conf();
@@ -252,7 +252,7 @@ RRDServer* RRDServer::init_rrdstorage( int argc, const char* const* argv,
     }
 
     dinfo << "(RRDServer): name = " << name << "(" << ID << ")" << endl;
-    return new RRDServer(ID,cnode,icID,ic,prefix);
+    return make_shared<RRDServer>(ID,cnode,icID,ic,prefix);
 }
 // -----------------------------------------------------------------------------
 void RRDServer::askSensors( UniversalIO::UIOCommand cmd )

extensions/RRDServer/RRDServer.h

@@ -58,13 +58,13 @@ class RRDServer:
     public UObject_SK
 {
     public:
-        RRDServer( UniSetTypes::ObjectId objId, xmlNode* cnode, UniSetTypes::ObjectId shmID, SharedMemory* ic=0,
+        RRDServer( UniSetTypes::ObjectId objId, xmlNode* cnode, UniSetTypes::ObjectId shmID, const std::shared_ptr<SharedMemory> ic=nullptr,
                     const std::string& prefix="rrd", DebugStream& log=UniSetExtensions::dlog );
         virtual ~RRDServer();
 
         /*! глобальная функция для инициализации объекта */
-        static RRDServer* init_rrdstorage( int argc, const char* const* argv,
-                            UniSetTypes::ObjectId shmID, SharedMemory* ic=0,
+        static std::shared_ptr<RRDServer> init_rrdstorage( int argc, const char* const* argv,
+                            UniSetTypes::ObjectId shmID, const std::shared_ptr<SharedMemory> ic=nullptr,
                             const std::string& prefix="rrd" );
 
         /*! глобальная функция для вывода help-а */
@@ -81,7 +81,7 @@ class RRDServer:
         void initRRD( xmlNode* cnode, int tmID );
         virtual void step() override;
 
-        SMInterface* shm;
+        std::shared_ptr<SMInterface> shm;
 
         struct DSInfo
         {

extensions/RRDServer/main.cc

@@ -50,15 +50,15 @@ int main( int argc, const char** argv )
             return 1;
         }
 
-        RRDServer* db = RRDServer::init_rrdstorage(argc,argv,shmID);
+        auto db = RRDServer::init_rrdstorage(argc,argv,shmID);
         if( !db )
         {
             dcrit << "(rrdstorage): init не прошёл..." << endl;
             return 1;
         }
 
-        UniSetActivatorPtr act = UniSetActivator::Instance();
-        act->addObject(static_cast<class UniSetObject*>(db));
+        auto act = UniSetActivator::Instance();
+        act->addObject(db);
 
         SystemMessage sm(SystemMessage::StartUp);
         act->broadcast( sm.transport_msg() );

extensions/SharedMemory/SharedMemory.cc

@@ -410,7 +410,7 @@ bool SharedMemory::readItem( const std::shared_ptr<UniXML>& xml, UniXML::iterato
     return true;
 }
 // ------------------------------------------------------------------------------------------
-SharedMemory* SharedMemory::init_smemory( int argc, const char* const* argv )
+shared_ptr<SharedMemory> SharedMemory::init_smemory( int argc, const char* const* argv )
 {
     auto conf = uniset_conf();
     string dfile = conf->getArgParam("--datfile", conf->getConfFileName());
@@ -429,8 +429,7 @@ SharedMemory* SharedMemory::init_smemory( int argc, const char* const* argv )
     }
 
     string cname = conf->getArgParam("--smemory--confnode", ORepHelpers::getShortName(conf->oind->getMapName(ID)) );
-
-    return new SharedMemory(ID,dfile,cname);
+    return make_shared<SharedMemory>(ID,dfile,cname);
 }
 // -----------------------------------------------------------------------------
 void SharedMemory::buildEventList( xmlNode* cnode )

extensions/SharedMemory/SharedMemory.h

@@ -3,6 +3,7 @@
 #define SharedMemory_H_
 // -----------------------------------------------------------------------------
 #include <string>
+#include <memory>
 #include <deque>
 #include "IONotifyController_LT.h"
 #include "Mutex.h"
@@ -260,7 +261,7 @@ class SharedMemory:
         virtual ~SharedMemory();
 
         /*! глобальная функция для инициализации объекта */
-        static SharedMemory* init_smemory( int argc, const char* const* argv );
+        static std::shared_ptr<SharedMemory> init_smemory( int argc, const char* const* argv );
         /*! глобальная функция для вывода help-а */
         static void help_print( int argc, const char* const* argv );
 

extensions/SharedMemory/smemory.cc

@@ -27,13 +27,13 @@ int main(int argc, const char **argv)
         ulog.logFile( logname );
         dlog.logFile( logname );
 
-        SharedMemory* shm = SharedMemory::init_smemory(argc, argv);
+        auto shm = SharedMemory::init_smemory(argc, argv);
         if( !shm )
             return 1;
 
         UniSetActivatorPtr act = UniSetActivator::Instance();
 
-        act->addObject(static_cast<class UniSetObject*>(shm));
+        act->addObject( shm ); // ->get_ptr() );
         SystemMessage sm(SystemMessage::StartUp);
         act->broadcast( sm.transport_msg() );
         act->run(false);

extensions/SharedMemoryPlus/smemory-plus.cc

@@ -75,14 +75,14 @@ int main( int argc, const char **argv )
         ulog.logFile( logname );
         conf->initDebug(UniSetExtensions::dlog,"dlog");
 
-        UniSetActivatorPtr act = UniSetActivator::Instance();
+        auto act = UniSetActivator::Instance();
         act->signal_terminate_event().connect( &activator_terminate );
         // ------------ SharedMemory ----------------
-        SharedMemory* shm = SharedMemory::init_smemory(argc,argv);
-        if( shm == NULL )
+        auto shm = SharedMemory::init_smemory(argc,argv);
+        if( !shm )
             return 1;
 
-        act->addManager(static_cast<class UniSetManager*>(shm));
+        act->addManager(shm);
 
 #ifdef UNISET_ENABLE_IO
         // ------------ IOControl ----------------
@@ -104,15 +104,15 @@ int main( int argc, const char **argv )
                 if( dlog.is_info() )
                     dlog.info() << "(smemory-plus): add IOControl(" << p.str() << ")" << endl;
 
-                IOControl* ic = IOControl::init_iocontrol(argc,argv,shm->getId(),shm,p.str());
-                if( ic == NULL )
+                auto ic = IOControl::init_iocontrol(argc,argv,shm->getId(),shm,p.str());
+                if( !ic )
                     return 1;
 
-                ThreadCreator<IOControl>* io_thr = new ThreadCreator<IOControl>(ic, &IOControl::execute);
+                ThreadCreator<IOControl>* io_thr = new ThreadCreator<IOControl>(ic.get(), &IOControl::execute);
                 if( io_thr == NULL )
                     return 1;
 
-                act->addObject(static_cast<class UniSetObject*>(ic));
+                act->addObject(ic);
                 lst_iothr.push_back( io_thr );
             }
         }
@@ -134,11 +134,11 @@ int main( int argc, const char **argv )
                 if( dlog.is_info() )
                     dlog.info() << "(smemory-plus): add RTUExchange(" << p.str() << ")" << endl;
 
-                RTUExchange* rtu = RTUExchange::init_rtuexchange(argc,argv,shm->getId(),shm,p.str());
-                if( rtu == NULL )
+                auto rtu = RTUExchange::init_rtuexchange(argc,argv,shm->getId(),shm,p.str());
+                if( !rtu )
                     return 1;
 
-                act->addObject(static_cast<class UniSetObject*>(rtu));
+                act->addObject(rtu);
             }
         }
         // ------------- MBSlave --------------
@@ -158,11 +158,11 @@ int main( int argc, const char **argv )
                 if( dlog.is_info() )
                     dlog.info() << "(smemory-plus): add MBSlave(" << p.str() << ")" << endl;
 
-                MBSlave* mbs = MBSlave::init_mbslave(argc,argv,shm->getId(),shm,p.str());
-                if( mbs == NULL )
+                auto mbs = MBSlave::init_mbslave(argc,argv,shm->getId(),shm,p.str());
+                if( !mbs )
                     return 1;
 
-                act->addObject(static_cast<class UniSetObject*>(mbs));
+                act->addObject(mbs);
             }
         }
 
@@ -184,25 +184,25 @@ int main( int argc, const char **argv )
                 if( dlog.is_info() )
                     dlog.info() << "(smemory-plus): add MBTCPMaster(" << p.str() << ")" << endl;
 
-                MBTCPMaster* mbm1 = MBTCPMaster::init_mbmaster(argc,argv,shm->getId(),shm,p.str());
-                if( mbm1 == NULL )
+                auto mbm1 = MBTCPMaster::init_mbmaster(argc,argv,shm->getId(),shm,p.str());
+                if( !mbm1 )
                     return 1;
 
-                act->addObject(static_cast<class UniSetObject*>(mbm1));
+                act->addObject(mbm1);
             }
         }
         // ------------- UNetUDP --------------
         bool add_unet = findArgParam("--add-unet",argc,argv) != -1;
         if( add_unet )
         {
-            UNetExchange* unet = UNetExchange::init_unetexchange(argc,argv,shm->getId(),shm);
+            auto unet = UNetExchange::init_unetexchange(argc,argv,shm->getId(),shm);
             if( unet == NULL )
                 return 1;
 
             if( dlog.is_info() )
                 dlog.info() << "(smemory-plus): add UNetExchnage.." << endl;
 
-            act->addObject(static_cast<class UniSetObject*>(unet));
+            act->addObject(unet);
         }
         // ---------------------------------------
            // попытка решить вопрос с "зомби" процессами

extensions/UNetUDP/UNetExchange.cc

@@ -7,7 +7,7 @@ using namespace std;
 using namespace UniSetTypes;
 using namespace UniSetExtensions;
 // -----------------------------------------------------------------------------
-UNetExchange::UNetExchange( UniSetTypes::ObjectId objId, UniSetTypes::ObjectId shmId, SharedMemory* ic, const std::string& prefix ):
+UNetExchange::UNetExchange( UniSetTypes::ObjectId objId, UniSetTypes::ObjectId shmId, const std::shared_ptr<SharedMemory> ic, const std::string& prefix ):
 UniSetObject_LT(objId),
 shm(0),
 initPause(0),
@@ -25,7 +25,7 @@ sender2(0)
     if( cnode == NULL )
         throw UniSetTypes::SystemError("(UNetExchange): Not found conf-node for " + myname );
 
-    shm = new SMInterface(shmId,&ui,objId,ic);
+    shm = make_shared<SMInterface>(shmId,&ui,objId,ic);
 
     UniXML::iterator it(cnode);
 
@@ -122,7 +122,7 @@ sender2(0)
             }
 
             dinfo << myname << "(init): init sender.. my node " << n_it.getProp("name") << endl;
-            sender = new UNetSender(h,p,shm,s_field,s_fvalue,ic);
+            sender = new UNetSender(h,p,shm,s_field,s_fvalue);
             sender->setSendPause(sendpause);
 
             try
@@ -131,7 +131,7 @@ sender2(0)
                 if( !h2.empty() )
                 {
                     dinfo << myname << "(init): init sender2.. my node " << n_it.getProp("name") << endl;
-                    sender2 = new UNetSender(h2,p2,shm,s_field,s_fvalue,ic);
+                    sender2 = new UNetSender(h2,p2,shm,s_field,s_fvalue);
                     sender2->setSendPause(sendpause);
                 }
             }
@@ -349,7 +349,6 @@ UNetExchange::~UNetExchange()
 
     delete sender;
     delete sender2;
-    delete shm;
 }
 // -----------------------------------------------------------------------------
 bool UNetExchange::checkExistUNetHost( const std::string& addr, ost::tpport_t port )
@@ -425,7 +424,7 @@ void UNetExchange::step()
 }
 
 // -----------------------------------------------------------------------------
-void UNetExchange::ReceiverInfo::step( SMInterface* shm, const std::string& myname )
+void UNetExchange::ReceiverInfo::step( const std::shared_ptr<SMInterface> shm, const std::string& myname )
 {
     try
     {
@@ -656,8 +655,8 @@ void UNetExchange::help_print( int argc, const char* argv[] )
     cout << "--prefix-filter-value name      - Значение фильтрующего поля при формировании списка датчиков посылаемых данным узлом" << endl;
 }
 // -----------------------------------------------------------------------------
-UNetExchange* UNetExchange::init_unetexchange( int argc, const char* const argv[], UniSetTypes::ObjectId icID,
-                                                SharedMemory* ic, const std::string& prefix )
+std::shared_ptr<UNetExchange> UNetExchange::init_unetexchange( int argc, const char* const argv[], UniSetTypes::ObjectId icID,
+                                                const std::shared_ptr<SharedMemory> ic, const std::string& prefix )
 {
     auto conf = uniset_conf();
 
@@ -678,7 +677,7 @@ UNetExchange* UNetExchange::init_unetexchange( int argc, const char* const argv[
     }
 
     dinfo << "(unetexchange): name = " << name << "(" << ID << ")" << endl;
-    return new UNetExchange(ID,icID,ic,prefix);
+    return make_shared<UNetExchange>(ID,icID,ic,prefix);
 }
 // -----------------------------------------------------------------------------
 void UNetExchange::receiverEvent( UNetReceiver* r, UNetReceiver::Event ev )

extensions/UNetUDP/UNetExchange.h

@@ -80,12 +80,12 @@ class UNetExchange:
     public UniSetObject_LT
 {
     public:
-        UNetExchange( UniSetTypes::ObjectId objId, UniSetTypes::ObjectId shmID, SharedMemory* ic=0, const std::string& prefix="unet" );
+        UNetExchange( UniSetTypes::ObjectId objId, UniSetTypes::ObjectId shmID, const std::shared_ptr<SharedMemory> ic=nullptr, const std::string& prefix="unet" );
         virtual ~UNetExchange();
 
         /*! глобальная функция для инициализации объекта */
-        static UNetExchange* init_unetexchange( int argc, const char* const argv[],
-                                            UniSetTypes::ObjectId shmID, SharedMemory* ic=0, const std::string& prefix="unet" );
+        static std::shared_ptr<UNetExchange> init_unetexchange( int argc, const char* const argv[],
+                                            UniSetTypes::ObjectId shmID, const std::shared_ptr<SharedMemory> ic=0, const std::string& prefix="unet" );
 
         /*! глобальная функция для вывода help-а */
         static void help_print( int argc, const char* argv[] );
@@ -98,7 +98,7 @@ class UNetExchange:
         std::string s_field;
         std::string s_fvalue;
 
-        SMInterface* shm;
+        std::shared_ptr<SMInterface> shm;
         void step();
 
         void sysCommand( const UniSetTypes::SystemMessage *msg ) override;
@@ -155,7 +155,7 @@ class UNetExchange:
             UNetReceiver* r1;      /*!< приём по первому каналу */
             UNetReceiver* r2;    /*!< приём по второму каналу */
 
-            void step( SMInterface* shm, const std::string& myname );
+            void step( const std::shared_ptr<SMInterface> shm, const std::string& myname );
 
             inline void setRespondID( UniSetTypes::ObjectId id, bool invert=false )
             { 
@@ -163,7 +163,7 @@ class UNetExchange:
                 respondInvert = invert;
             }
             inline void setLostPacketsID( UniSetTypes::ObjectId id ){ sidLostPackets = id; }
-            inline void initIterators( SMInterface* shm )
+            inline void initIterators( const std::shared_ptr<SMInterface> shm )
             {
                 shm->initIterator(itLostPackets);
                 shm->initIterator(itRespond);

extensions/UNetUDP/UNetReceiver.cc

@@ -19,7 +19,7 @@ bool UNetReceiver::PacketCompare::operator()(const UniSetUDP::UDPMessage& lhs,
 }
 */
 // ------------------------------------------------------------------------------------------
-UNetReceiver::UNetReceiver( const std::string& s_host, const ost::tpport_t port, SMInterface* smi ):
+UNetReceiver::UNetReceiver( const std::string& s_host, const ost::tpport_t port, const std::shared_ptr<SMInterface> smi ):
 shm(smi),
 recvpause(10),
 updatepause(100),
@@ -388,11 +388,12 @@ void UNetReceiver::receive()
         {
             dwarn << myname << "(receive): " << e.what()<< std::endl;
         }
+/*
         catch(...)
         {
             dwarn << myname << "(receive): catch ..." << std::endl;
         }
-
+*/
         // делаем через промежуточную переменную
         // чтобы поскорее освободить mutex
         {

extensions/UNetUDP/UNetReceiver.h

@@ -52,7 +52,7 @@
 class UNetReceiver
 {
     public:
-        UNetReceiver( const std::string& host, const ost::tpport_t port, SMInterface* smi );
+        UNetReceiver( const std::string& host, const ost::tpport_t port, const std::shared_ptr<SMInterface> smi );
         ~UNetReceiver();
 
          void start();
@@ -100,7 +100,7 @@ class UNetReceiver
 
     protected:
 
-        SMInterface* shm;
+        const std::shared_ptr<SMInterface> shm;
 
         bool recv();
         void step();

extensions/UNetUDP/UNetSender.cc

@@ -8,8 +8,8 @@ using namespace std;
 using namespace UniSetTypes;
 using namespace UniSetExtensions;
 // -----------------------------------------------------------------------------
-UNetSender::UNetSender( const std::string& s_host, const ost::tpport_t port, SMInterface* smi,
-                        const std::string& s_f, const std::string& s_val, SharedMemory* ic ):
+UNetSender::UNetSender( const std::string& s_host, const ost::tpport_t port, const std::shared_ptr<SMInterface> smi,
+                        const std::string& s_f, const std::string& s_val ):
 s_field(s_f),
 s_fvalue(s_val),
 shm(smi),
@@ -68,7 +68,18 @@ s_thr(0)
         dinfo << myname << "(init): dlist size = " << dlist.size() << endl;
     }
     else
+    {
+        auto ic = std::dynamic_pointer_cast<SharedMemory>(shm->SM());
+        if( ic )
             ic->addReadItem( sigc::mem_fun(this,&UNetSender::readItem) );
+        else
+        {
+            dwarn << myname << "(init): Failed to convert the pointer 'IONotifyController' -> 'SharedMemory'" << endl;
+            readConfiguration();
+            dlist.resize(maxItem);
+            dinfo << myname << "(init): dlist size = " << dlist.size() << endl;
+        }
+    }
 
 
     // выставляем поля, которые не меняются
@@ -80,7 +91,6 @@ UNetSender::~UNetSender()
 {
     delete s_thr;
     delete udp;
-    delete shm;
 }
 // -----------------------------------------------------------------------------
 void UNetSender::updateFromSM()

extensions/UNetUDP/UNetSender.h

@@ -21,8 +21,8 @@
 class UNetSender
 {
     public:
-        UNetSender( const std::string& host, const ost::tpport_t port, SMInterface* smi,
-                    const std::string& s_field="", const std::string& s_fvalue="", SharedMemory* ic=0 );
+        UNetSender( const std::string& host, const ost::tpport_t port, const std::shared_ptr<SMInterface> smi,
+                    const std::string& s_field="", const std::string& s_fvalue="" );
 
         ~UNetSender();
 
@@ -71,7 +71,7 @@ class UNetSender
         std::string s_field;
         std::string s_fvalue;
 
-        SMInterface* shm;
+        const std::shared_ptr<SMInterface> shm;
 
         bool initItem( UniXML::iterator& it );
         bool readItem( const std::shared_ptr<UniXML>& xml, UniXML::iterator& it, xmlNode* sec );

extensions/UNetUDP/tests/tests_with_sm.cc

@@ -36,18 +36,18 @@ int main(int argc, char* argv[] )
 
         bool apart = findArgParam("--apart",argc,argv) != -1;
 
-        SharedMemory* shm = SharedMemory::init_smemory(argc, argv);
+        auto shm = SharedMemory::init_smemory(argc, argv);
         if( !shm )
             return 1;
 
-        UNetExchange* unet = UNetExchange::init_unetexchange(argc,argv,shm->getId(), (apart ? nullptr : shm ));
+        auto unet = UNetExchange::init_unetexchange(argc,argv,shm->getId(), (apart ? nullptr : shm ));
         if( !unet )
             return 1;
 
-        UniSetActivatorPtr act = UniSetActivator::Instance();
+        auto act = UniSetActivator::Instance();
 
-        act->addObject(static_cast<class UniSetObject*>(shm));
-        act->addObject(static_cast<class UniSetObject*>(unet));
+        act->addObject(shm);
+        act->addObject(unet);
 
         SystemMessage sm(SystemMessage::StartUp);
         act->broadcast( sm.transport_msg() );

extensions/UNetUDP/unetexchange.cc

@@ -48,15 +48,15 @@ int main( int argc, const char** argv )
             return 1;
         }
 
-        UNetExchange* unet = UNetExchange::init_unetexchange(argc,argv,shmID);
+        auto unet = UNetExchange::init_unetexchange(argc,argv,shmID);
         if( !unet )
         {
             dcrit << "(unetexchange): init failed.." << endl;
             return 1;
         }
 
-        UniSetActivatorPtr act = UniSetActivator::Instance();
-        act->addObject(static_cast<class UniSetObject*>(unet));
+        auto act = UniSetActivator::Instance();
+        act->addObject(unet);
 
         SystemMessage sm(SystemMessage::StartUp);
         act->broadcast( sm.transport_msg() );

extensions/UniNetwork/UniExchange.cc

@@ -18,7 +18,7 @@ UniExchange::NetNodeInfo::NetNodeInfo():
 }
 // --------------------------------------------------------------------------
 UniExchange::UniExchange( UniSetTypes::ObjectId id, UniSetTypes::ObjectId shmID, 
-                            SharedMemory* ic, const std::string& prefix ):
+                          const std::shared_ptr<SharedMemory> ic, const std::string& prefix ):
 IOController(id),
 shm(0),
 polltime(200),
@@ -327,8 +327,8 @@ void UniExchange::sigterm( int signo )
 {
 }
 // -----------------------------------------------------------------------------
-UniExchange* UniExchange::init_exchange( int argc, const char* const* argv, 
-                                        UniSetTypes::ObjectId icID, SharedMemory* ic,
+std::shared_ptr<UniExchange> UniExchange::init_exchange( int argc, const char* const* argv,
+                                        UniSetTypes::ObjectId icID, const std::shared_ptr<SharedMemory> ic,
                                             const std::string& prefix )
 {
     auto conf = uniset_conf();
@@ -343,7 +343,7 @@ UniExchange* UniExchange::init_exchange( int argc, const char* const* argv,
             << " in section " << conf->getControllersSection() << endl;
         return 0;
     }
-    return new UniExchange(ID,icID,ic,prefix);
+    return make_shared<UniExchange>(ID,icID,ic,prefix);
 }
 // -----------------------------------------------------------------------------
 void UniExchange::readConfiguration()

extensions/UniNetwork/UniExchange.h

@@ -37,13 +37,13 @@ class UniExchange:
 {
     public:
         UniExchange( UniSetTypes::ObjectId id, UniSetTypes::ObjectId shmID,
-                        SharedMemory* ic=0, const std::string& prefix="unet" );
+                     const std::shared_ptr<SharedMemory> ic=nullptr, const std::string& prefix="unet" );
         virtual ~UniExchange();
 
         void execute();
 
-        static UniExchange* init_exchange( int argc, const char* const* argv,
-                                    UniSetTypes::ObjectId shmID, SharedMemory* ic=0,
+        static std::shared_ptr<UniExchange> init_exchange( int argc, const char* const* argv,
+                                    UniSetTypes::ObjectId shmID, const std::shared_ptr<SharedMemory> ic=nullptr,
                                     const std::string& prefix="unet" );
 
         /*! глобальная функция для вывода help-а */

extensions/UniNetwork/uninet.cc

@@ -40,17 +40,17 @@ int main(int argc, const char **argv)
             return 1;
         }
 
-        UniExchange* shm = UniExchange::init_exchange(argc, argv, shmID);
-        if( !shm )
+        auto uex = UniExchange::init_exchange(argc, argv, shmID);
+        if( !uex )
             return 1;
 
-        UniSetActivatorPtr act = UniSetActivator::Instance();
+        auto act = UniSetActivator::Instance();
 
-        act->addObject(static_cast<class UniSetObject*>(shm));
+        act->addObject(uex);
         SystemMessage sm(SystemMessage::StartUp);
         act->broadcast( sm.transport_msg() );
         act->run(true);
-        shm->execute();
+        uex->execute();
         on_sigchild(SIGTERM);
         return 0;
     }

extensions/include/SMInterface.h

@@ -11,7 +11,7 @@ class SMInterface
     public:
 
         SMInterface( UniSetTypes::ObjectId _shmID, UInterface* ui,
-                        UniSetTypes::ObjectId myid, IONotifyController* ic=0 );
+                        UniSetTypes::ObjectId myid, const std::shared_ptr<IONotifyController> ic=nullptr );
         ~SMInterface();
 
         void setValue ( UniSetTypes::ObjectId, long value );
@@ -49,11 +49,11 @@ class SMInterface
 
         inline bool isLocalwork(){ return (ic==NULL); }
         inline UniSetTypes::ObjectId ID(){ return myid; }
-        inline IONotifyController* SM(){ return ic; }
+        inline const std::shared_ptr<IONotifyController> SM(){ return ic; }
         inline UniSetTypes::ObjectId getSMID(){ return shmID; }
 
     protected:
-        IONotifyController* ic;
+        const std::shared_ptr<IONotifyController> ic;
         UInterface* ui;
         CORBA::Object_var oref;
         UniSetTypes::ObjectId shmID;

extensions/lib/SMInterface.cc

@@ -85,7 +85,7 @@ using namespace UniSetTypes;
 
 // --------------------------------------------------------------------------
 SMInterface::SMInterface( UniSetTypes::ObjectId _shmID, UInterface* _ui,
-                            UniSetTypes::ObjectId _myid, IONotifyController* ic ):
+                            UniSetTypes::ObjectId _myid, const std::shared_ptr<IONotifyController> ic ):
     ic(ic),
     ui(_ui),
     oref( CORBA::Object::_nil() ),

extensions/tests/test_iobase_with_sm.cc

@@ -10,11 +10,13 @@ using namespace std;
 using namespace UniSetTypes;
 using namespace UniSetExtensions;
 // -----------------------------------------------------------------------------
-static SMInterface* shm = nullptr;
+static std::shared_ptr<SMInterface> shared_shm;
+static SMInterface* shm;
 static void init_test()
 {
-    shm = smiInstance();
-    CHECK( shm != nullptr );
+    shared_shm = smiInstance();
+    CHECK( shared_shm != nullptr );
+    shm = shared_shm.get();
 }
 
 static bool init_iobase( IOBase* ib, const std::string& sensor )

extensions/tests/tests_with_sm.cc

 #define CATCH_CONFIG_RUNNER
 #include <catch.hpp>
 
+#include <memory>
 #include <string>
 #include "Debug.h"
 #include "UniSetActivator.h"
@@ -13,20 +14,20 @@ using namespace std;
 using namespace UniSetTypes;
 using namespace UniSetExtensions;
 // --------------------------------------------------------------------------
-static SMInterface* smi = nullptr;
-static SharedMemory* shm = nullptr;
+static shared_ptr<SMInterface> smi;
+static shared_ptr<SharedMemory> shm;
 static UInterface* ui = nullptr;
 static ObjectId myID = 6000;
 // --------------------------------------------------------------------------
-SharedMemory* shmInstance()
+shared_ptr<SharedMemory> shmInstance()
 {
-    if( shm == nullptr )
+    if( !shm )
         throw SystemError("SharedMemory don`t initialize..");
 
     return shm;
 }
 // --------------------------------------------------------------------------
-SMInterface* smiInstance()
+shared_ptr<SMInterface> smiInstance()
 {
     if( smi == nullptr )
     {
@@ -36,7 +37,7 @@ SMInterface* smiInstance()
         if( ui == nullptr )
             ui = new UInterface();
 
-        smi = new SMInterface(shm->getId(), ui, myID, shm );
+        smi = make_shared<SMInterface>(shm->getId(), ui, myID, shm );
     }
 
     return smi;
@@ -60,7 +61,7 @@ int main(int argc, char* argv[] )
    
     try
     {
-        uniset_init(argc,argv);
+        auto conf = uniset_init(argc,argv);
 /*
         conf->initDebug(dlog,"dlog");
         string logfilename = conf->getArgParam("--logfile", "smemory.log");
@@ -72,9 +73,10 @@ int main(int argc, char* argv[] )
         if( !shm )
             return 1;
 
-        UniSetActivatorPtr act = UniSetActivator::Instance();
+        auto act = UniSetActivator::Instance();
+
 
-        act->addObject(static_cast<class UniSetObject*>(shm));
+        act->addObject(shm);
         SystemMessage sm(SystemMessage::StartUp);
         act->broadcast( sm.transport_msg() );
         act->run(true);
@@ -93,6 +95,8 @@ int main(int argc, char* argv[] )
         int ret = session.run();
 
         act->oaDestroy();
+		act.reset();
+        conf.reset();
         return ret;
     }
     catch( SystemError& err )

extensions/tests/tests_with_sm.h

@@ -8,7 +8,7 @@
 // Для некоторых тестов необходим SMInterface инициализированный для работы с SharedMemory
 // поэтому сделана такая специальная функция
 // реализацию смотри в tests_with_sm.cc
-SMInterface* smiInstance();
-SharedMemory* shmInstance();
+std::shared_ptr<SMInterface> smiInstance();
+std::shared_ptr<SharedMemory> shmInstance();
 // --------------------------------------------------------------------------
 #endif // tests_with_sm_H_

include/UniSetActivator.h

@@ -60,6 +60,7 @@ class UniSetActivator:
         static UniSetActivatorPtr Instance( const UniSetTypes::ObjectId id=UniSetTypes::DefaultObjectId );
         void Destroy();
 
+        std::shared_ptr<UniSetActivator> get_aptr(){ return std::dynamic_pointer_cast<UniSetActivator>(get_ptr()); }
         // ------------------------------------
         virtual ~UniSetActivator();
 
@@ -142,15 +143,15 @@ class UniSetActivator:
         struct OInfo:
             public Info
         {
-            OInfo( UniSetObject* o, pid_t p ):Info(p),obj(o){}
-            UniSetObject* obj;
+            OInfo( std::shared_ptr<UniSetObject> o, pid_t p ):Info(p),obj(o){}
+            std::shared_ptr<UniSetObject> obj;
         };
 
         struct MInfo:
             public Info
         {
-            MInfo( UniSetManager* m, pid_t p ):Info(p),mnr(m){}
-            UniSetManager* mnr;
+            MInfo( std::shared_ptr<UniSetManager> m, pid_t p ):Info(p),mnr(m){}
+            std::shared_ptr<UniSetManager> mnr;
         };
 
         std::deque<OInfo> lstOInfo;

include/UniSetManager.h

@@ -26,6 +26,7 @@
 #define UniSetManager_H_
 // -------------------------------------------------------------------------- 
 #include <omniORB4/CORBA.h>
+#include <memory>
 #include "UniSetTypes.h"
 #include "UniSetObject.h"
 #include "UniSetManager_i.hh"
@@ -33,7 +34,7 @@
 class UniSetActivator;
 
 class UniSetManager;
-typedef std::list<UniSetManager*> UniSetManagerList;        
+typedef std::list< std::shared_ptr<UniSetManager> > UniSetManagerList;
 //---------------------------------------------------------------------------
 /*! \class UniSetManager
  *    \par
@@ -62,6 +63,8 @@ class UniSetManager:
         UniSetManager( const std::string& name, const std::string& section );
         virtual ~UniSetManager();
 
+        std::shared_ptr<UniSetManager> get_mptr() { return std::dynamic_pointer_cast<UniSetManager>(get_ptr()); }
+
         virtual UniSetTypes::ObjectType getType() override { return UniSetTypes::ObjectType("UniSetManager"); }
 
         // ------  функции объявленные в интерфейсе(IDL) ------
@@ -71,23 +74,22 @@ class UniSetManager:
         // --------------------------
         void initPOA(UniSetManager* rmngr);
 
-        virtual bool addObject(UniSetObject *obj);
-        virtual bool removeObject(UniSetObject *obj);
-
-        virtual bool addManager( UniSetManager *mngr );
-        virtual bool removeManager( UniSetManager *mngr );
+        virtual bool addObject( std::shared_ptr<UniSetObject> obj );
+        virtual bool removeObject( std::shared_ptr<UniSetObject> obj );
 
+        virtual bool addManager( std::shared_ptr<UniSetManager> mngr );
+        virtual bool removeManager( std::shared_ptr<UniSetManager> mngr );
 
         /*! Получение доступа к подчиненному менеджеру по идентификатору
          * \return объект ненайден будет возвращен 0.
         */ 
-        const UniSetManager* itemM(const UniSetTypes::ObjectId id);
+        const std::shared_ptr<UniSetManager> itemM(const UniSetTypes::ObjectId id);
 
 
         /*! Получение доступа к подчиненному объекту по идентификатору
          * \return объект ненайден будет возвращен 0.
         */ 
-        const UniSetObject* itemO( const UniSetTypes::ObjectId id );
+        const std::shared_ptr<UniSetObject> itemO( const UniSetTypes::ObjectId id );
 
 
         // Функции для аботы со списками подчиненных объектов
@@ -137,7 +139,7 @@ class UniSetManager:
 
         typedef UniSetManagerList::iterator MListIterator;
 
-        int getObjectsInfo( UniSetManager* mngr, UniSetTypes::SimpleInfoSeq* seq, 
+        int getObjectsInfo( const std::shared_ptr<UniSetManager>& mngr, UniSetTypes::SimpleInfoSeq* seq,
                             int begin, const long uplimit );
 
         PortableServer::POA_var poa;    

include/UniSetObject.h

@@ -30,6 +30,7 @@
 #include <sys/time.h>
 #include <queue>
 #include <ostream>
+#include <memory>
 #include <string>
 #include <list>
 
@@ -49,7 +50,7 @@ class UniSetManager;
 
 //---------------------------------------------------------------------------
 class UniSetObject;
-typedef std::list<UniSetObject *> ObjectsList;     /*!< Список подчиненных объектов */
+typedef std::list< std::shared_ptr<UniSetObject> > ObjectsList;     /*!< Список подчиненных объектов */
 //---------------------------------------------------------------------------
 /*! \class UniSetObject
  *    Класс задает такие свойства объекта как: получение сообщений, помещение сообщения в очередь и т.п.
@@ -62,6 +63,7 @@ typedef std::list<UniSetObject *> ObjectsList;     /*!< Список подчи
  *    на разработчика.
 */ 
 class UniSetObject:
+    public std::enable_shared_from_this<UniSetObject>,
     public POA_UniSetObject_i
 {
     public:
@@ -70,6 +72,8 @@ class UniSetObject:
         UniSetObject();
         virtual ~UniSetObject();
 
+        std::shared_ptr<UniSetObject> get_ptr(){ return shared_from_this(); }
+
         // Функции объявленные в IDL
         virtual CORBA::Boolean exist() override;
 

src/ObjectRepository/UniSetActivator.cc

@@ -81,7 +81,7 @@ UniSetActivatorPtr UniSetActivator::Instance( const UniSetTypes::ObjectId id )
 {
     if( inst == nullptr )
     {
-       inst = shared_ptr<UniSetActivator>( new UniSetActivator(id) );
+        inst = std::shared_ptr<UniSetActivator>( new UniSetActivator(id) );
         gActivator = inst;
     }
 

src/ObjectRepository/UniSetManager.cc

@@ -39,11 +39,11 @@ using namespace UniSetTypes;
 using namespace std;
 // ------------------------------------------------------------------------------------------
 // объект-функция для посылки сообщения менеджеру
-class MPush: public unary_function<UniSetManager*, bool>
+class MPush: public unary_function< const std::shared_ptr<UniSetManager>& , bool>
 {
     public: 
         MPush(const UniSetTypes::TransportMessage& msg):msg(msg){}
-        bool operator()(UniSetManager* m) const
+        bool operator()( const std::shared_ptr<UniSetManager>& m ) const
         {
             try
             {
@@ -60,11 +60,11 @@ class MPush: public unary_function<UniSetManager*, bool>
 };
 
 // объект-функция для посылки сообщения объекту
-class OPush: public unary_function<UniSetObject*, bool>
+class OPush: public unary_function< const std::shared_ptr<UniSetObject>& , bool>
 {
     public: 
         OPush(const UniSetTypes::TransportMessage& msg):msg(msg){}
-        bool operator()(UniSetObject* o) const
+        bool operator()( const std::shared_ptr<UniSetObject>& o ) const
         {
             try
             {
@@ -169,7 +169,7 @@ void UniSetManager::initPOA( UniSetManager* rmngr )
     managers(initial);
 }
 // ------------------------------------------------------------------------------------------
-bool UniSetManager::addObject( UniSetObject *obj )
+bool UniSetManager::addObject( std::shared_ptr<UniSetObject> obj )
 {
     {    //lock
         uniset_rwmutex_wrlock lock(olistMutex);
@@ -184,7 +184,7 @@ bool UniSetManager::addObject( UniSetObject *obj )
 }
 
 // ------------------------------------------------------------------------------------------
-bool UniSetManager::removeObject( UniSetObject* obj )
+bool UniSetManager::removeObject( std::shared_ptr<UniSetObject> obj )
 {
     {    //lock
         uniset_rwmutex_wrlock lock(olistMutex);
@@ -194,6 +194,7 @@ bool UniSetManager::removeObject( UniSetObject* obj )
             uinfo << myname << "(activator): удаляем объект "<< obj->getName()<< endl;
             try
             {
+                if(obj)
                     obj->deactivate();
             }
             catch(Exception& ex)
@@ -235,6 +236,8 @@ void UniSetManager::managers( OManagerCommand cmd )
         uniset_rwmutex_rlock lock(mlistMutex);
         for( auto &li: mlist )
         {
+            if( !li )
+                continue;
             try
             {
                 switch(cmd)
@@ -295,6 +298,8 @@ void UniSetManager::objects(OManagerCommand cmd)
 
         for( auto &li: olist )
         {
+            if( !li )
+                continue;
             try
             {
                 switch(cmd)
@@ -409,7 +414,7 @@ void UniSetManager::broadcast(const TransportMessage& msg)
 }
 
 // ------------------------------------------------------------------------------------------
-bool UniSetManager::addManager( UniSetManager *child )
+bool UniSetManager::addManager( std::shared_ptr<UniSetManager> child )
 {
     {    //lock
         uniset_rwmutex_wrlock lock(mlistMutex);
@@ -429,7 +434,7 @@ bool UniSetManager::addManager( UniSetManager *child )
 }
 
 // ------------------------------------------------------------------------------------------
-bool UniSetManager::removeManager( UniSetManager* child )
+bool UniSetManager::removeManager( std::shared_ptr<UniSetManager> child )
 {
     {    //lock
         uniset_rwmutex_wrlock lock(mlistMutex);
@@ -441,7 +446,7 @@ bool UniSetManager::removeManager( UniSetManager* child )
 
 // ------------------------------------------------------------------------------------------
 
-const UniSetManager* UniSetManager::itemM(const ObjectId id)
+const std::shared_ptr<UniSetManager> UniSetManager::itemM( const ObjectId id )
 {
 
     {    //lock
@@ -458,7 +463,7 @@ const UniSetManager* UniSetManager::itemM(const ObjectId id)
 
 // ------------------------------------------------------------------------------------------
 
-const UniSetObject* UniSetManager::itemO(const ObjectId id)
+const std::shared_ptr<UniSetObject> UniSetManager::itemO( const ObjectId id )
 {
     {    //lock
         uniset_rwmutex_rlock lock(olistMutex);
@@ -469,7 +474,7 @@ const UniSetObject* UniSetManager::itemO(const ObjectId id)
         }
     } // unlock
 
-    return 0;
+    return std::shared_ptr<UniSetObject>();
 }
 
 // ------------------------------------------------------------------------------------------
@@ -488,7 +493,7 @@ int UniSetManager::objectsCount()
 }
 
 // ------------------------------------------------------------------------------------------
-int UniSetManager::getObjectsInfo( UniSetManager* mngr, SimpleInfoSeq* seq, 
+int UniSetManager::getObjectsInfo( const std::shared_ptr<UniSetManager>& mngr, SimpleInfoSeq* seq,
                                     int begin, const long uplimit )
 {
     auto ind = begin;
@@ -550,7 +555,8 @@ SimpleInfoSeq* UniSetManager::getObjectsInfo( CORBA::Long maxlength )
     // используем рекурсивную функцию
     int ind = 0;
     const int limit = length; 
-    ind = getObjectsInfo( this, res, ind, limit );
+
+    ind = getObjectsInfo( get_mptr(), res, ind, limit );
     return res;
 }