Improve:SharedData module.

test/utils/SharedData/src/SharedData_Test.cpp

@@ -24,22 +24,22 @@ TEST(SharedDataTest, Demo)
     CreateLogModule();
     ILogInit(LOG_INSTANCE_TYPE_END);
     constexpr int PROJECT_ID = 9;
-    SharedData *sharedDataPrimary = CreateSharedData(SHARER_NAME_PRIMARY, "./shared_file", PROJECT_ID);
+    void *sharedDataPrimary = CreateSharedData(SHARER_NAME_PRIMARY, "./shared_file", PROJECT_ID);
-    SharedData *sharedDataMinor = CreateSharedData(SHARER_NAME_MINOR, "./shared_file", PROJECT_ID);
+    void *sharedDataMinor = CreateSharedData(SHARER_NAME_MINOR, "./shared_file", PROJECT_ID);
     if (nullptr != sharedDataMinor) {
         int writableData = 99;
-        sharedDataMinor->mMakeSharedData(sharedDataMinor, sizeof(int), sizeof(int));
+        IMakeSharedData(sharedDataMinor, sizeof(int), sizeof(int));
-        sharedDataMinor->mSetWritableData(sharedDataMinor, &writableData, sizeof(int));
+        ISetWritableData(sharedDataMinor, &writableData, sizeof(int));
     }
     if (nullptr != sharedDataPrimary) {
         int readableData = -1;
-        sharedDataPrimary->mMakeSharedData(sharedDataPrimary, sizeof(int), sizeof(int));
+        IMakeSharedData(sharedDataPrimary, sizeof(int), sizeof(int));
-        sharedDataPrimary->mGetReadableData(sharedDataPrimary, &readableData, sizeof(int));
+        IGetReadableData(sharedDataPrimary, &readableData, sizeof(int));
         LogInfo("readableData = %d\n", readableData);
-        sharedDataPrimary->mFree(sharedDataPrimary);
+        IShareDataFree(sharedDataPrimary);
     }
     if (nullptr != sharedDataMinor) {
-        sharedDataMinor->mFree(sharedDataMinor);
+        IShareDataFree(sharedDataMinor);
     }
     ILogUnInit();
 }
@@ -50,8 +50,8 @@ TEST(SharedDataTest, Demo2)
     CreateLogModule();
     ILogInit(LOG_INSTANCE_TYPE_END);
     constexpr int PROJECT_ID = 9;
-    SharedData *sharedDataPrimary = CreateSharedData(SHARER_NAME_PRIMARY, "./shared_file", PROJECT_ID);
+    void *sharedDataPrimary = CreateSharedData(SHARER_NAME_PRIMARY, "./shared_file", PROJECT_ID);
-    SharedData *sharedDataMinor = CreateSharedData(SHARER_NAME_MINOR, "./shared_file", PROJECT_ID);
+    void *sharedDataMinor = CreateSharedData(SHARER_NAME_MINOR, "./shared_file", PROJECT_ID);
     if (nullptr != sharedDataMinor) {
         IMakeSharedData(sharedDataMinor, sizeof(int), sizeof(int));
         ISetWritableData(sharedDataMinor, (void *)&WRITABLE_DATA, sizeof(int));
@@ -76,8 +76,8 @@ TEST(SharedDataTest, Demo3)
     CreateLogModule();
     ILogInit(LOG_INSTANCE_TYPE_END);
     constexpr int PROJECT_ID = 9;
-    SharedData *sharedDataPrimary = CreateSharedData(SHARER_NAME_PRIMARY, "./shared_file", PROJECT_ID);
+    void *sharedDataPrimary = CreateSharedData(SHARER_NAME_PRIMARY, "./shared_file", PROJECT_ID);
-    SharedData *sharedDataMinor = CreateSharedData(SHARER_NAME_MINOR, "./shared_file", PROJECT_ID);
+    void *sharedDataMinor = CreateSharedData(SHARER_NAME_MINOR, "./shared_file", PROJECT_ID);
     if (nullptr != sharedDataMinor) {
         constexpr int WRITABLE_DATA_LENGTH = 9;
         char writableData[WRITABLE_DATA_LENGTH] = {0};
@@ -107,8 +107,8 @@ TEST(SharedDataTest, Demo4)
     CreateLogModule();
     ILogInit(LOG_INSTANCE_TYPE_END);
     constexpr int PROJECT_ID = 9;
-    SharedData *sharedDataPrimary = CreateSharedData(SHARER_NAME_PRIMARY, "./shared_file", PROJECT_ID);
+    void *sharedDataPrimary = CreateSharedData(SHARER_NAME_PRIMARY, "./shared_file", PROJECT_ID);
-    SharedData *sharedDataMinor = CreateSharedData(SHARER_NAME_MINOR, "./shared_file", PROJECT_ID);
+    void *sharedDataMinor = CreateSharedData(SHARER_NAME_MINOR, "./shared_file", PROJECT_ID);
     if (nullptr != sharedDataMinor) {
         IMakeSharedData(sharedDataMinor, sizeof(int) * 2, sizeof(int));
         ISetWritableData(sharedDataMinor, (void *)&WRITABLE_DATA, sizeof(int));
@@ -135,7 +135,7 @@ TEST(SharedDataTest, Demo5)
     CreateLogModule();
     ILogInit(LOG_INSTANCE_TYPE_END);
     constexpr int PROJECT_ID = 9;
-    SharedData *sharedDataPrimary = CreateSharedData(SHARER_NAME_PRIMARY, "./shared_file", PROJECT_ID);
+    void *sharedDataPrimary = CreateSharedData(SHARER_NAME_PRIMARY, "./shared_file", PROJECT_ID);
     if (nullptr != sharedDataPrimary) {
         constexpr int DEFAULT_DATA = 0;
         int readableData = DEFAULT_DATA;
@@ -155,8 +155,8 @@ TEST(SharedDataTest, Demo6)
     CreateLogModule();
     ILogInit(LOG_INSTANCE_TYPE_END);
     constexpr int PROJECT_ID = 9;
-    SharedData *sharedDataPrimary = CreateSharedData(SHARER_NAME_PRIMARY, "./shared_file", PROJECT_ID);
+    void *sharedDataPrimary = CreateSharedData(SHARER_NAME_PRIMARY, "./shared_file", PROJECT_ID);
-    SharedData *sharedDataMinor = CreateSharedData(SHARER_NAME_MINOR, "./shared_file", PROJECT_ID);
+    void *sharedDataMinor = CreateSharedData(SHARER_NAME_MINOR, "./shared_file", PROJECT_ID);
     if (nullptr != sharedDataPrimary) {
         constexpr int DEFAULT_DATA = 0;
         int readableData = DEFAULT_DATA;
@@ -180,8 +180,8 @@ TEST(SharedDataTest, Demo7)
     CreateLogModule();
     ILogInit(LOG_INSTANCE_TYPE_END);
     constexpr int PROJECT_ID = 9;
-    SharedData *sharedDataPrimary = CreateSharedData(SHARER_NAME_PRIMARY, "./shared_file", PROJECT_ID);
+    void *sharedDataPrimary = CreateSharedData(SHARER_NAME_PRIMARY, "./shared_file", PROJECT_ID);
-    SharedData *sharedDataMinor = CreateSharedData(SHARER_NAME_MINOR, "./shared_file", PROJECT_ID);
+    void *sharedDataMinor = CreateSharedData(SHARER_NAME_MINOR, "./shared_file", PROJECT_ID);
     if (nullptr != sharedDataPrimary) {
         IMakeSharedData(sharedDataPrimary, sizeof(int), sizeof(int));
         ISetWritableData(sharedDataPrimary, (void *)&WRITABLE_DATA, sizeof(int));
@@ -209,8 +209,8 @@ TEST(SharedDataTest, UNIT_SharedData_DEME_Demo7)
     CreateLogModule();
     ILogInit(LOG_INSTANCE_TYPE_END);
     constexpr int PROJECT_ID = 9;
-    SharedData *sharedDataPrimary = CreateSharedData(SHARER_NAME_PRIMARY, "./shared_file", PROJECT_ID);
+    void *sharedDataPrimary = CreateSharedData(SHARER_NAME_PRIMARY, "./shared_file", PROJECT_ID);
-    SharedData *sharedDataMinor = CreateSharedData(SHARER_NAME_MINOR, "./shared_file", PROJECT_ID);
+    void *sharedDataMinor = CreateSharedData(SHARER_NAME_MINOR, "./shared_file", PROJECT_ID);
     if (nullptr != sharedDataPrimary) {
         IMakeSharedData(sharedDataPrimary, sizeof(int) * 2, sizeof(int));
         ISetWritableData(sharedDataPrimary, (void *)&WRITABLE_DATA, sizeof(int));
@@ -237,8 +237,8 @@ TEST(SharedDataTest, UNIT_SharedData_DEME_Demo8)
     CreateLogModule();
     ILogInit(LOG_INSTANCE_TYPE_END);
     constexpr int PROJECT_ID = 9;
-    SharedData *sharedDataPrimary = CreateSharedData(SHARER_NAME_PRIMARY, "./shared_file", PROJECT_ID);
+    void *sharedDataPrimary = CreateSharedData(SHARER_NAME_PRIMARY, "./shared_file", PROJECT_ID);
-    SharedData *sharedDataMinor = CreateSharedData(SHARER_NAME_MINOR, "./shared_file", PROJECT_ID);
+    void *sharedDataMinor = CreateSharedData(SHARER_NAME_MINOR, "./shared_file", PROJECT_ID);
     if (nullptr != sharedDataPrimary) {
         int writableData[2] = {0};
         IMakeSharedData(sharedDataPrimary, sizeof(int), sizeof(int) * 2);
@@ -267,8 +267,8 @@ TEST(SharedDataTest, UNIT_SharedData_DEME_Demo9)
     CreateLogModule();
     ILogInit(LOG_INSTANCE_TYPE_END);
     constexpr int PROJECT_ID = 9;
-    SharedData *sharedDataPrimary = CreateSharedData(SHARER_NAME_PRIMARY, "./shared_file", PROJECT_ID);
+    void *sharedDataPrimary = CreateSharedData(SHARER_NAME_PRIMARY, "./shared_file", PROJECT_ID);
-    SharedData *sharedDataMinor = CreateSharedData(SHARER_NAME_MINOR, "./shared_file", PROJECT_ID);
+    void *sharedDataMinor = CreateSharedData(SHARER_NAME_MINOR, "./shared_file", PROJECT_ID);
     if (nullptr != sharedDataPrimary) {
         IMakeSharedData(sharedDataPrimary, sizeof(int), sizeof(int));
         ISetWritableData(sharedDataPrimary, (void *)&WRITABLE_DATA, sizeof(int));
@@ -296,8 +296,8 @@ TEST(SharedDataTest, UNIT_SharedData_DEME_Demo10)
     CreateLogModule();
     ILogInit(LOG_INSTANCE_TYPE_END);
     constexpr int PROJECT_ID = 9;
-    SharedData *sharedDataPrimary = CreateSharedData(SHARER_NAME_PRIMARY, "./shared_file", PROJECT_ID);
+    void *sharedDataPrimary = CreateSharedData(SHARER_NAME_PRIMARY, "./shared_file", PROJECT_ID);
-    SharedData *sharedDataMinor = CreateSharedData(SHARER_NAME_MINOR, "./shared_file", PROJECT_ID);
+    void *sharedDataMinor = CreateSharedData(SHARER_NAME_MINOR, "./shared_file", PROJECT_ID);
     if (nullptr != sharedDataPrimary) {
         IMakeSharedData(sharedDataPrimary, sizeof(int), sizeof(int));
         ISetWritableData(sharedDataPrimary, (void *)&WRITABLE_DATA, sizeof(int));
@@ -323,8 +323,8 @@ TEST(SharedDataTest, UNIT_SharedData_DEME_Demo11)
     CreateLogModule();
     ILogInit(LOG_INSTANCE_TYPE_END);
     constexpr int PROJECT_ID = 9;
-    SharedData *sharedDataPrimary = CreateSharedData(SHARER_NAME_PRIMARY, "./shared_file", PROJECT_ID);
+    void *sharedDataPrimary = CreateSharedData(SHARER_NAME_PRIMARY, "./shared_file", PROJECT_ID);
-    SharedData *sharedDataMinor = CreateSharedData(SHARER_NAME_MINOR, "./shared_file", PROJECT_ID);
+    void *sharedDataMinor = CreateSharedData(SHARER_NAME_MINOR, "./shared_file", PROJECT_ID);
     IMakeSharedData(sharedDataMinor, sizeof(int), sizeof(int));
     if (nullptr != sharedDataPrimary) {
         IMakeSharedData(sharedDataPrimary, sizeof(int), sizeof(int));

utils/ConfigBase/src/IConfigBase.cpp

@@ -105,7 +105,7 @@ const char *GetConfigBaseModuleName(void)
 }
 std::shared_ptr<IConfigBase> *NewConfigBase(const char *fileName)
 {
-    LogInfo("Create the uart device object.\n");
+    LogInfo("Create the config base object.\n");
     ConfigBase *impl = (ConfigBase *)malloc(sizeof(ConfigBase));
     if (nullptr == impl) {
         LogError("NewConfigBase::malloc failed.\n");

utils/SharedData/CMakeLists.txt

@@ -13,8 +13,6 @@ include_directories(
 #     ${EXTERNAL_SOURCE_PATH}/libconfig/libconfig-1.7.3/lib/.libs
 # )
 
-
-
 aux_source_directory(./src SRC_FILES)
 
 set(TARGET_NAME SharedData)

utils/SharedData/include/SharedData.h

@@ -30,37 +30,12 @@ enum SHARER_NAME
     SHARER_NAME_MINOR,
     SHARER_NAME_END
 };
-typedef struct shared_data SharedData;
+void *CreateSharedData(const enum SHARER_NAME name, const char *path, const int projectId);
-typedef struct shared_data
+const StatusCode IMakeSharedData(void *object, const unsigned int readableSize, const unsigned int writableSize);
-{
+const StatusCode ICleanSharedData(void *object);
-    const StatusCode (*mMakeSharedData)(SharedData *, const unsigned int, const unsigned int);
+const StatusCode IGetReadableData(void *object, void *buf, const unsigned int bufLength);
-    const StatusCode (*mCleanSharedData)(SharedData *);
+void ISetWritableData(void *object, void *buf, const unsigned int bufLength);
-    const StatusCode (*mGetReadableData)(SharedData *, void *, const unsigned int);
+void IShareDataFree(void *object);
-    void (*mSetWritableData)(SharedData *, void *, const unsigned int);
-    void (*mFree)(void *);
-} SharedData;
-SharedData *CreateSharedData(const enum SHARER_NAME name, const char *path, const int projectId);
-static inline const StatusCode IMakeSharedData(SharedData *object, const unsigned int readableSize,
-                                               const unsigned int writableSize)
-{
-    return object->mMakeSharedData(object, readableSize, writableSize);
-}
-static inline const StatusCode ICleanSharedData(SharedData *object)
-{
-    return object->mCleanSharedData(object);
-}
-static inline const StatusCode IGetReadableData(SharedData *object, void *buf, const unsigned int bufLength)
-{
-    return object->mGetReadableData(object, buf, bufLength);
-}
-static inline void ISetWritableData(SharedData *object, void *buf, const unsigned int bufLength)
-{
-    object->mSetWritableData(object, buf, bufLength);
-}
-static inline void IShareDataFree(SharedData *object)
-{
-    object->mFree(object);
-}
 #ifdef __cplusplus
 }
 #endif

utils/SharedData/src/ISharedData.cpp

@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "ISharedData.h"
+#include "ILog.h"
+#include "SharedDataImpl.h" // TODO: 互相包含，需要修改
+#include <string.h>
+void ISharedData::MakeSharedMemory(const unsigned int readableSize, const unsigned int writableSize)
+{
+}
+const StatusCode ISharedData::GetReadableMemory(void *buf, const unsigned int &bufLength)
+{
+    return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
+}
+void ISharedData::SetWritableMemory(void *buf, const unsigned int &bufLength)
+{
+}
+StatusCode ISharedData::FreeSharedMemory(void)
+{
+    return CreateStatusCode(STATUS_CODE_VIRTUAL_FUNCTION);
+}
+static const char *SHARED_DATA_NAME = "shared_data";
+const char *GetSharedDataModuleName(void)
+{
+    return SHARED_DATA_NAME;
+}
+std::shared_ptr<ISharedData> *NewSharedData(const enum SHARER_NAME &name, const char *path, const int &projectId)
+{
+    LogInfo("Create the shared data object.\n");
+    SharedData *impl = (SharedData *)malloc(sizeof(SharedData));
+    if (nullptr == impl) {
+        LogError("NewConfigBase::malloc failed.\n");
+        return nullptr;
+    }
+    SharedData tmp;
+    memcpy((void *)impl, (void *)&tmp, sizeof(SharedData));
+    impl->mHeader.mCheckName = SHARED_DATA_NAME;
+    impl->mISharedData = std::make_shared<SharedDataImpl>(name, path, projectId);
+    return (std::shared_ptr<ISharedData> *)(((char *)impl) + sizeof(ISharedDataHeader));
+}

utils/SharedData/src/ISharedData.h

@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2023 Fancy Code.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef I_SHARED_DATA_H
+#define I_SHARED_DATA_H
+#include "SharedData.h"
+#include "StatusCode.h"
+#include <memory>
+class ISharedData
+{
+public:
+    ISharedData() = default;
+    virtual ~ISharedData() = default;
+    virtual void MakeSharedMemory(const unsigned int readableSize, const unsigned int writableSize);
+    virtual const StatusCode GetReadableMemory(void *buf, const unsigned int &bufLength);
+    virtual void SetWritableMemory(void *buf, const unsigned int &bufLength);
+    virtual StatusCode FreeSharedMemory(void);
+};
+typedef struct i_shared_data_header
+{
+    const char *mCheckName;
+} ISharedDataHeader;
+typedef struct config_base
+{
+    ISharedDataHeader mHeader;
+    std::shared_ptr<ISharedData> mISharedData;
+} SharedData;
+const char *GetSharedDataModuleName(void);
+std::shared_ptr<ISharedData> *NewSharedData(const enum SHARER_NAME &name, const char *path, const int &projectId);
+#endif

utils/SharedData/src/SharedData.cpp

@@ -13,8 +13,62 @@
  * limitations under the License.
  */
 #include "SharedData.h"
-#include "SharedDataImpl.h"
+#include "ILog.h"
-SharedData *CreateSharedData(const enum SHARER_NAME name, const char *path, const int projectId)
+#include "ISharedData.h"
+static bool ObjectCheck(void *object)
 {
-    return (SharedData *)NewSharedDataImpl(name, path, projectId);
+    if (nullptr == object) {
+        LogError("nullptr object!\n");
+        return false;
+    }
+    if (*((const char **)(((char *)object) - sizeof(ISharedDataHeader))) != GetSharedDataModuleName()) {
+        LogError("Illegal object!\n");
+        return false;
+    }
+    return true;
+}
+void *CreateSharedData(const enum SHARER_NAME name, const char *path, const int projectId)
+{
+    std::shared_ptr<ISharedData> *sharedDataObject = NewSharedData(name, path, projectId);
+    if (nullptr != sharedDataObject) {
+        // (*sharedDataObject)->OpenConfigFile();
+    }
+    return sharedDataObject;
+}
+const StatusCode IMakeSharedData(void *object, const unsigned int readableSize, const unsigned int writableSize)
+{
+    if (ObjectCheck(object) == true) {
+        (*(std::shared_ptr<ISharedData> *)object)->MakeSharedMemory(readableSize, writableSize);
+        return CreateStatusCode(STATUS_CODE_OK);
+    }
+    return CreateStatusCode(STATUS_CODE_INVALID_PARAMENTER);
+}
+const StatusCode ICleanSharedData(void *object)
+{
+    if (ObjectCheck(object) == true) {
+        // (*(std::shared_ptr<ISharedData> *)object)->MakeSharedMemory(readableSize, writableSize);
+        return CreateStatusCode(STATUS_CODE_INVALID_PARAMENTER);
+    }
+    return CreateStatusCode(STATUS_CODE_INVALID_PARAMENTER);
+}
+const StatusCode IGetReadableData(void *object, void *buf, const unsigned int bufLength)
+{
+    if (ObjectCheck(object) == true) {
+        return (*(std::shared_ptr<ISharedData> *)object)->GetReadableMemory(buf, bufLength);
+    }
+    return CreateStatusCode(STATUS_CODE_INVALID_PARAMENTER);
+}
+void ISetWritableData(void *object, void *buf, const unsigned int bufLength)
+{
+    if (ObjectCheck(object) == true) {
+        (*(std::shared_ptr<ISharedData> *)object)->SetWritableMemory(buf, bufLength);
+    }
+}
+void IShareDataFree(void *object)
+{
+    if (ObjectCheck(object) == true) {
+        (*(std::shared_ptr<ISharedData> *)object)->FreeSharedMemory();
+        (*(std::shared_ptr<ISharedData> *)object).reset();
+        free(((char *)object) - sizeof(ISharedDataHeader));
+    }
 }

utils/SharedData/src/SharedDataImpl.cpp

@@ -18,14 +18,14 @@
 #include <cstring>
 static const char *SHARED_DATA_NAME = "shared_data";
 constexpr short THERE_TWO_USER_DATA_HEADER = 2;
-SharedDataCpp::SharedDataCpp(const SHARER_NAME &sharerName, const char *path, const int &projectId)
+SharedDataImpl::SharedDataImpl(const SHARER_NAME &sharerName, const char *path, const int &projectId)
     : SharedMemory(path, projectId), mSharerName(sharerName)
 {
     mPrimaryReadSize = 0;
     mMinorReadSize = 0;
     mSharedMemeory = nullptr;
 }
-void SharedDataCpp::MakeSharedMemory(const unsigned int readableSize, const unsigned int writableSize)
+void SharedDataImpl::MakeSharedMemory(const unsigned int readableSize, const unsigned int writableSize)
 {
     if (SHARER_NAME_PRIMARY == mSharerName) {
         mPrimaryReadSize = readableSize;
@@ -44,29 +44,7 @@ void SharedDataCpp::MakeSharedMemory(const unsigned int readableSize, const unsi
     mSharedMemeory = SharedMemory::GetMemory();
     WritableDataInit();
 }
-void SharedDataCpp::WritableDataInit(void)
+const StatusCode SharedDataImpl::GetReadableMemory(void *buf, const unsigned int &bufLength)
-{
-    if (nullptr == mSharedMemeory) {
-        LogError("mSharedMemeory is nullptr, failed.\n");
-        return;
-    }
-    if (SHARER_NAME_PRIMARY == mSharerName) {
-        UserDataHeader *writableHeader =
-            (UserDataHeader *)((char *)mSharedMemeory + sizeof(UserDataHeader) + mPrimaryReadSize);
-        memcpy(writableHeader->mUserName, USER_NAME_INIT_NAME, USER_NAME_BUF_LENGTH);
-        writableHeader->mDataLength = mMinorReadSize;
-    }
-    else if (SHARER_NAME_MINOR == mSharerName) {
-        UserDataHeader *writableHeader = (UserDataHeader *)((char *)mSharedMemeory);
-        memcpy(writableHeader->mUserName, USER_NAME_INIT_NAME, USER_NAME_BUF_LENGTH);
-        writableHeader->mDataLength = mPrimaryReadSize;
-    }
-    else {
-        LogError("Make shared memory failed.\n");
-        return;
-    }
-}
-const StatusCode SharedDataCpp::GetReadableMemory(void *buf, const unsigned int &bufLength)
 {
     if (nullptr == mSharedMemeory) {
         LogError("mSharedMemeory is nullptr, failed.\n");
@@ -105,7 +83,7 @@ const StatusCode SharedDataCpp::GetReadableMemory(void *buf, const unsigned int
     }
     return CreateStatusCode(STATUS_CODE_OK);
 }
-void SharedDataCpp::SetWritableMemory(void *buf, const unsigned int &bufLength)
+void SharedDataImpl::SetWritableMemory(void *buf, const unsigned int &bufLength)
 {
     if (nullptr == mSharedMemeory) {
         LogError("mSharedMemeory is nullptr, failed.\n");
@@ -136,45 +114,29 @@ void SharedDataCpp::SetWritableMemory(void *buf, const unsigned int &bufLength)
         LogError("Set writable memory failed.\n");
     }
 }
-static const StatusCode MakeSharedData(SharedData *object, const unsigned int readableSize,
+StatusCode SharedDataImpl::FreeSharedMemory(void)
-                                       const unsigned int writableSize)
 {
-    SharedDataImpl *impl = ((SharedDataImpl *)(((char *)object) - sizeof(SharedDataHeader)));
+    return CleanSharedMemory();
-    impl->mSharedData->MakeSharedMemory(readableSize, writableSize);
-    return CreateStatusCode(STATUS_CODE_OK);
 }
-static const StatusCode GetSharedReadableMemory(SharedData *object, void *buf, const unsigned int bufLength)
+void SharedDataImpl::WritableDataInit(void)
 {
-    SharedDataImpl *impl = ((SharedDataImpl *)(((char *)object) - sizeof(SharedDataHeader)));
+    if (nullptr == mSharedMemeory) {
-    return impl->mSharedData->GetReadableMemory(buf, bufLength);
+        LogError("mSharedMemeory is nullptr, failed.\n");
-}
+        return;
-static void SetSharedWritableMemory(SharedData *object, void *buf, const unsigned int bufLength)
+    }
-{
+    if (SHARER_NAME_PRIMARY == mSharerName) {
-    SharedDataImpl *impl = ((SharedDataImpl *)(((char *)object) - sizeof(SharedDataHeader)));
+        UserDataHeader *writableHeader =
-    impl->mSharedData->SetWritableMemory(buf, bufLength);
+            (UserDataHeader *)((char *)mSharedMemeory + sizeof(UserDataHeader) + mPrimaryReadSize);
-}
+        memcpy(writableHeader->mUserName, USER_NAME_INIT_NAME, USER_NAME_BUF_LENGTH);
-static void SharedDataImplFree(void *ptr)
+        writableHeader->mDataLength = mMinorReadSize;
-{
+    }
-    SharedDataImpl *object = ((SharedDataImpl *)(((char *)ptr) - sizeof(SharedDataHeader)));
+    else if (SHARER_NAME_MINOR == mSharerName) {
-    if (SHARED_DATA_NAME == object->mHeader.mCheckName) {
+        UserDataHeader *writableHeader = (UserDataHeader *)((char *)mSharedMemeory);
-        object->mSharedData->CleanSharedMemory();
+        memcpy(writableHeader->mUserName, USER_NAME_INIT_NAME, USER_NAME_BUF_LENGTH);
-        object->mSharedData = nullptr;
+        writableHeader->mDataLength = mPrimaryReadSize;
-        free(((char *)ptr) - sizeof(SharedDataHeader));
     }
     else {
-        LogError("Unknow ptr.\n");
+        LogError("Make shared memory failed.\n");
+        return;
     }
 }
-SharedData *NewSharedDataImpl(const SHARER_NAME &name, const char *path, const int &projectId)
-{
-    SharedDataImpl *impl = (SharedDataImpl *)malloc(sizeof(SharedDataImpl));
-    SharedDataImpl tmp;
-    memcpy((void *)impl, (void *)&tmp, sizeof(SharedDataImpl));
-    impl->mHeader.mCheckName = SHARED_DATA_NAME;
-    impl->mBase.mMakeSharedData = MakeSharedData;
-    impl->mBase.mGetReadableData = GetSharedReadableMemory;
-    impl->mBase.mSetWritableData = SetSharedWritableMemory;
-    impl->mBase.mFree = SharedDataImplFree;
-    impl->mSharedData = std::make_shared<SharedDataCpp>(name, path, projectId);
-    return (SharedData *)(((char *)impl) + sizeof(SharedDataHeader));
-}

utils/SharedData/src/SharedDataImpl.h

@@ -14,10 +14,10 @@
  */
 #ifndef SHARED_DATA_IMPL_H
 #define SHARED_DATA_IMPL_H
-#include "SharedData.h"
+#include "ISharedData.h"
 #include "SharedMemory.h"
 #include <memory>
-#include <mutex>
+// #include <mutex>
 constexpr int USER_NAME_BUF_LENGTH = 4;
 #define USER_NAME_INIT_NAME "XING"
 enum USER_DATA_INIT
@@ -41,14 +41,15 @@ typedef struct user_data_header
     unsigned int mDataLength;
     int mIsInit;
 } UserDataHeader;
-class SharedDataCpp : public SharedMemory
+class SharedDataImpl : public ISharedData, public SharedMemory
 {
 public:
-    SharedDataCpp(const SHARER_NAME &sharerName, const char *path, const int &projectId);
+    SharedDataImpl(const SHARER_NAME &sharerName, const char *path, const int &projectId);
-    virtual ~SharedDataCpp() = default;
+    virtual ~SharedDataImpl() = default;
-    void MakeSharedMemory(const unsigned int readableSize, const unsigned int writableSize);
+    void MakeSharedMemory(const unsigned int readableSize, const unsigned int writableSize) override;
-    const StatusCode GetReadableMemory(void *buf, const unsigned int &bufLength);
+    const StatusCode GetReadableMemory(void *buf, const unsigned int &bufLength) override;
-    void SetWritableMemory(void *buf, const unsigned int &bufLength);
+    void SetWritableMemory(void *buf, const unsigned int &bufLength) override;
+    StatusCode FreeSharedMemory(void) override;
 
 private:
     void WritableDataInit(void);
@@ -59,12 +60,4 @@ private:
     unsigned int mMinorReadSize;
     void *mSharedMemeory;
 };
-typedef struct shared_data_impl SharedDataImpl;
-typedef struct shared_data_impl
-{
-    SharedDataHeader mHeader;
-    SharedData mBase;
-    std::shared_ptr<SharedDataCpp> mSharedData;
-} SharedDataImpl;
-SharedData *NewSharedDataImpl(const SHARER_NAME &name, const char *path, const int &projectId);
 #endif