revise memory management of module

* revise memory management of module
* change shared_ptr to unique_ptr

diff --git a/common/MQProxy.cc b/common/MQProxy.cc
index 0c259de..92ec58f 100644 (file)
--- a/common/MQProxy.cc
+++ b/common/MQProxy.cc
@@ -29,7 +29,7 @@ MQProxy::MQProxy(const std::string &id, bool clear_session, bool is_custom_broke
 
         mq = loader.LoadMqttClient(handle.get(), "test", true);
     } else {
-        mq = std::shared_ptr<MQ>(new MosquittoMQ(id, clear_session));
+        mq = std::unique_ptr<MQ>(new MosquittoMQ(id, clear_session));
     }
 }
 

diff --git a/common/MQProxy.h b/common/MQProxy.h
index 68a30f2..5da8e09 100644 (file)
--- a/common/MQProxy.h
+++ b/common/MQProxy.h
@@ -42,7 +42,7 @@ class MQProxy : public MQ {
 
   private:
     std::unique_ptr<void, void (*)(const void *)> handle;
-    std::shared_ptr<MQ> mq;
+    std::unique_ptr<MQ> mq;
 };
 
 }  // namespace aitt

diff --git a/common/ModuleLoader.cc b/common/ModuleLoader.cc
index 51cdc78..8dae2fe 100644 (file)
--- a/common/ModuleLoader.cc
+++ b/common/ModuleLoader.cc
@@ -52,33 +52,32 @@ ModuleLoader::ModuleHandle ModuleLoader::OpenModule(Type type)
     return handle;
 }
 
-std::shared_ptr<AittTransport> ModuleLoader::LoadTransport(void *handle, const std::string &ip,
+std::unique_ptr<AittTransport> ModuleLoader::LoadTransport(void *handle, const std::string &ip,
       AittDiscovery &discovery)
 {
     if (handle == nullptr) {
         ERR("handle is NULL");
-        return std::shared_ptr<AittTransport>(new NullTransport(ip.c_str(), discovery));
+        return std::unique_ptr<AittTransport>(new NullTransport(ip.c_str(), discovery));
     }
 
     AittTransport::ModuleEntry get_instance_fn = reinterpret_cast<AittTransport::ModuleEntry>(
           dlsym(handle, AittTransport::MODULE_ENTRY_NAME));
     if (get_instance_fn == nullptr) {
         ERR("dlsym: %s", dlerror());
-        return std::shared_ptr<AittTransport>(new NullTransport(ip.c_str(), discovery));
+        return std::unique_ptr<AittTransport>(new NullTransport(ip.c_str(), discovery));
     }
 
-    std::shared_ptr<AittTransport> instance(
-          static_cast<AittTransport *>(get_instance_fn(ip.c_str(), discovery)),
-          [](const AittTransport *instance) -> void { delete instance; });
+    std::unique_ptr<AittTransport> instance(
+          static_cast<AittTransport *>(get_instance_fn(ip.c_str(), discovery)));
     if (instance == nullptr) {
-        ERR("Failed to create a new instance");
-        return std::shared_ptr<AittTransport>(new NullTransport(ip.c_str(), discovery));
+        ERR("get_instance_fn(AittTransport) Fail");
+        return std::unique_ptr<AittTransport>(new NullTransport(ip.c_str(), discovery));
     }
 
     return instance;
 }
 
-std::shared_ptr<MQ> ModuleLoader::LoadMqttClient(void *handle, const std::string &id,
+std::unique_ptr<MQ> ModuleLoader::LoadMqttClient(void *handle, const std::string &id,
       bool clear_session)
 {
     MQ::ModuleEntry get_instance_fn =
@@ -88,10 +87,9 @@ std::shared_ptr<MQ> ModuleLoader::LoadMqttClient(void *handle, const std::string
         throw AittException(AittException::SYSTEM_ERR);
     }
 
-    std::shared_ptr<MQ> instance(static_cast<MQ *>(get_instance_fn(id.c_str(), clear_session)),
-          [](const MQ *instance) { delete instance; });
+    std::unique_ptr<MQ> instance(static_cast<MQ *>(get_instance_fn(id.c_str(), clear_session)));
     if (instance == nullptr) {
-        ERR("Failed to create a new instance");
+        ERR("get_instance_fn(MQ) Fail");
         throw AittException(AittException::SYSTEM_ERR);
     }
 

diff --git a/common/ModuleLoader.h b/common/ModuleLoader.h
index 66e339d..c122ace 100644 (file)
--- a/common/ModuleLoader.h
+++ b/common/ModuleLoader.h
@@ -41,9 +41,9 @@ class ModuleLoader {
     virtual ~ModuleLoader() = default;
 
     ModuleHandle OpenModule(Type type);
-    std::shared_ptr<AittTransport> LoadTransport(void *handle, const std::string &ip,
+    std::unique_ptr<AittTransport> LoadTransport(void *handle, const std::string &ip,
           AittDiscovery &discovery);
-    std::shared_ptr<MQ> LoadMqttClient(void *handle, const std::string &id, bool clear_session);
+    std::unique_ptr<MQ> LoadMqttClient(void *handle, const std::string &id, bool clear_session);
 
   private:
     std::string GetModuleFilename(Type type);

diff --git a/src/AITTImpl.cc b/src/AITTImpl.cc
index ac19457..abb8754 100644 (file)
--- a/src/AITTImpl.cc
+++ b/src/AITTImpl.cc
@@ -38,18 +38,18 @@ AITT::Impl::Impl(AITT &parent, const std::string &id, const std::string &my_ip,
         mq(new MQProxy(id, clear_session, custom_broker)),
         discovery(id, custom_broker),
         reply_id(0),
-        modules{0}
+        transports{0}
 {
     // TODO: Validate my_ip
     ModuleLoader loader;
     for (ModuleLoader::Type i = ModuleLoader::TYPE_TCP; i < ModuleLoader::TYPE_TRANSPORT_MAX;
           i = ModuleLoader::Type(i + 1)) {
-        ModuleLoader::ModuleHandle handle = loader.OpenModule(i);
+        module_handles.push_back(loader.OpenModule(i));
+        const ModuleLoader::ModuleHandle &handle = module_handles.back();
         if (handle == nullptr)
             ERR("OpenModule() Fail");
 
-        modules[i] = new ModuleObj(std::move(handle),
-              loader.LoadTransport(handle.get(), my_ip, discovery));
+        transports[i] = loader.LoadTransport(handle.get(), my_ip, discovery);
     }
     aittThread = std::thread(&AITT::Impl::ThreadMain, this);
 }
@@ -66,11 +66,6 @@ AITT::Impl::~Impl(void)
 
     if (aittThread.joinable())
         aittThread.join();
-
-    for (ModuleLoader::Type i = ModuleLoader::TYPE_TCP; i < ModuleLoader::TYPE_TRANSPORT_MAX;
-          i = ModuleLoader::Type(i + 1)) {
-        delete modules[i];
-    }
 }
 
 void AITT::Impl::ThreadMain(void)
@@ -132,10 +127,10 @@ void AITT::Impl::UnsubscribeAll()
             mq->Unsubscribe(subscribe_info->second);
             break;
         case AITT_TYPE_TCP:
-            GetTransport(ModuleLoader::TYPE_TCP)->Unsubscribe(subscribe_info->second);
+            transports[ModuleLoader::TYPE_TCP]->Unsubscribe(subscribe_info->second);
             break;
         case AITT_TYPE_WEBRTC:
-            GetTransport(ModuleLoader::TYPE_WEBRTC)->Unsubscribe(subscribe_info->second);
+            transports[ModuleLoader::TYPE_WEBRTC]->Unsubscribe(subscribe_info->second);
             break;
 
         default:
@@ -148,11 +143,6 @@ void AITT::Impl::UnsubscribeAll()
     subscribed_list.clear();
 }
 
-inline std::shared_ptr<AittTransport> AITT::Impl::GetTransport(ModuleLoader::Type type)
-{
-    return modules[type]->second;
-}
-
 void AITT::Impl::ConfigureTransportModule(const std::string &key, const std::string &value,
       AittProtocol protocols)
 {
@@ -165,7 +155,7 @@ void AITT::Impl::Publish(const std::string &topic, const void *data, const size_
         mq->Publish(topic, data, datalen, qos, retain);
 
     if ((protocols & AITT_TYPE_TCP) == AITT_TYPE_TCP)
-        GetTransport(ModuleLoader::TYPE_TCP)->Publish(topic, data, datalen, qos, retain);
+        transports[ModuleLoader::TYPE_TCP]->Publish(topic, data, datalen, qos, retain);
 
     if ((protocols & AITT_TYPE_WEBRTC) == AITT_TYPE_WEBRTC)
         PublishWebRtc(topic, data, datalen, qos, retain);
@@ -174,7 +164,6 @@ void AITT::Impl::Publish(const std::string &topic, const void *data, const size_
 void AITT::Impl::PublishWebRtc(const std::string &topic, const void *data, const size_t datalen,
       AittQoS qos, bool retain)
 {
-    auto webrtcModule = GetTransport(ModuleLoader::TYPE_WEBRTC);
     flexbuffers::Builder fbb;
     fbb.Map([=, &fbb]() {
         fbb.String("Id", id_ + WEBRTC_ID_POSTFIX);
@@ -187,7 +176,7 @@ void AITT::Impl::PublishWebRtc(const std::string &topic, const void *data, const
     });
     fbb.Finish();
     auto buf = fbb.GetBuffer();
-    webrtcModule->Publish(topic, buf.data(), buf.size(), qos, retain);
+    transports[ModuleLoader::TYPE_WEBRTC]->Publish(topic, buf.data(), buf.size(), qos, retain);
 }
 
 AittSubscribeID AITT::Impl::Subscribe(const std::string &topic, const AITT::SubscribeCallback &cb,
@@ -273,13 +262,11 @@ void *AITT::Impl::Unsubscribe(AittSubscribeID subscribe_id)
         user_data = mq->Unsubscribe(found_info->second);
         break;
     case AITT_TYPE_TCP: {
-        auto tcpModule = GetTransport(ModuleLoader::TYPE_TCP);
-        user_data = tcpModule->Unsubscribe(found_info->second);
+        user_data = transports[ModuleLoader::TYPE_TCP]->Unsubscribe(found_info->second);
         break;
     }
     case AITT_TYPE_WEBRTC: {
-        auto webrtcModule = GetTransport(ModuleLoader::TYPE_WEBRTC);
-        user_data = webrtcModule->Unsubscribe(found_info->second);
+        user_data = transports[ModuleLoader::TYPE_WEBRTC]->Unsubscribe(found_info->second);
         break;
     }
     default:
@@ -405,8 +392,7 @@ void AITT::Impl::SendReply(MSG *msg, const void *data, const int datalen, bool e
 void *AITT::Impl::SubscribeTCP(SubscribeInfo *handle, const std::string &topic,
       const SubscribeCallback &cb, void *user_data, AittQoS qos)
 {
-    auto tcpModule = GetTransport(ModuleLoader::TYPE_TCP);
-    return tcpModule->Subscribe(
+    return transports[ModuleLoader::TYPE_TCP]->Subscribe(
           topic,
           [handle, cb](const std::string &topic, const void *data, const size_t datalen,
                 void *user_data, const std::string &correlation) -> void {
@@ -424,7 +410,6 @@ void *AITT::Impl::SubscribeTCP(SubscribeInfo *handle, const std::string &topic,
 void *AITT::Impl::SubscribeWebRtc(SubscribeInfo *handle, const std::string &topic,
       const SubscribeCallback &cb, void *user_data, AittQoS qos)
 {
-    auto webrtc_module = GetTransport(ModuleLoader::TYPE_WEBRTC);
     flexbuffers::Builder fbb;
     fbb.Map([=, &fbb]() {
         fbb.String("Id", id_ + WEBRTC_ID_POSTFIX);
@@ -435,7 +420,7 @@ void *AITT::Impl::SubscribeWebRtc(SubscribeInfo *handle, const std::string &topi
     fbb.Finish();
     auto buf = fbb.GetBuffer();
 
-    return webrtc_module->Subscribe(
+    return transports[ModuleLoader::TYPE_WEBRTC]->Subscribe(
           topic,
           [handle, cb](const std::string &topic, const void *data, const size_t datalen,
                 void *user_data, const std::string &correlation) -> void {

diff --git a/src/AITTImpl.h b/src/AITTImpl.h
index aa26e3b..c794cd3 100644 (file)
--- a/src/AITTImpl.h
+++ b/src/AITTImpl.h
@@ -66,7 +66,6 @@ class AITT::Impl {
   private:
     using Blob = std::pair<const void *, int>;
     using SubscribeInfo = std::pair<AittProtocol, void *>;
-    using ModuleObj = std::pair<ModuleLoader::ModuleHandle, std::shared_ptr<AittTransport>>;
 
     void ConnectionCB(ConnectionCallback cb, void *user_data, int status);
     AittSubscribeID SubscribeMQ(SubscribeInfo *info, MainLoopHandler *loop_handle,
@@ -83,7 +82,6 @@ class AITT::Impl {
     void PublishWebRtc(const std::string &topic, const void *data, const size_t datalen,
           AittQoS qos, bool retain);
     void UnsubscribeAll();
-    std::shared_ptr<AittTransport> GetTransport(ModuleLoader::Type type);
 
     AITT &public_api;
     std::string id_;
@@ -92,7 +90,8 @@ class AITT::Impl {
     std::unique_ptr<MQ> mq;
     AittDiscovery discovery;
     unsigned short reply_id;
-    ModuleObj *modules[ModuleLoader::TYPE_TRANSPORT_MAX];
+    std::vector<ModuleLoader::ModuleHandle> module_handles;
+    std::unique_ptr<AittTransport> transports[ModuleLoader::TYPE_TRANSPORT_MAX];
     MainLoopHandler main_loop;
     void ThreadMain(void);
     std::thread aittThread;