Update VaultRecordSet operations

mrognor · Dec 24, 2024 · 88a4f21 · 88a4f21
1 parent 6851f08
commit 88a4f21
Show file tree

Hide file tree

Showing 10 changed files with 414 additions and 93 deletions.
diff --git a/Examples/CMakeLists.txt b/Examples/CMakeLists.txt
@@ -2,15 +2,15 @@ cmake_minimum_required(VERSION 3.6)
 
 if(WIN32)
     if (CMAKE_BUILD_TYPE STREQUAL "Release")
-        set(CMAKE_CXX_FLAGS "-Wall -O3")
+        set(CMAKE_CXX_FLAGS "-Wextra -O3")
     else()
-        set(CMAKE_CXX_FLAGS "-Wall -g")
+        set(CMAKE_CXX_FLAGS "-Wextra -g")
     endif()
 else()
     if (CMAKE_BUILD_TYPE STREQUAL "Release")
-        set(CMAKE_CXX_FLAGS "-Wall -O3")
+        set(CMAKE_CXX_FLAGS "-Wextra -O3")
     else()
-        set(CMAKE_CXX_FLAGS "-Wall -fsanitize=address -fsanitize=leak -lgcov --coverage -g")
+        set(CMAKE_CXX_FLAGS "-Wextra -fsanitize=address -fsanitize=leak -lgcov --coverage -g")
     endif()
 endif()
 

diff --git a/Source/CMakeLists.txt b/Source/CMakeLists.txt
@@ -2,15 +2,15 @@ cmake_minimum_required(VERSION 3.6)
 
 if(WIN32)
     if (CMAKE_BUILD_TYPE STREQUAL "Release")
-        set(CMAKE_CXX_FLAGS "-Wall -O3")
+        set(CMAKE_CXX_FLAGS "-Wextra -O3")
     else()
-        set(CMAKE_CXX_FLAGS "-Wall -g")
+        set(CMAKE_CXX_FLAGS "-Wextra -g")
     endif()
 else()
     if (CMAKE_BUILD_TYPE STREQUAL "Release")
-        set(CMAKE_CXX_FLAGS "-Wall -O3")
+        set(CMAKE_CXX_FLAGS "-Wextra -O3")
     else()
-        set(CMAKE_CXX_FLAGS "-Wall -fsanitize=address -fsanitize=leak -lgcov --coverage -g")
+        set(CMAKE_CXX_FLAGS "-Wextra -fsanitize=address -fsanitize=leak -lgcov --coverage -g")
     endif()
 endif()
 
@@ -36,7 +36,6 @@ set(MVaultHeaders
     Functions/CsvParser.h
     Functions/FromString.h
     Functions/PrintAsTable.h
-    Functions/VaultRecordSetOperations.h
 )
 
 set(MVaultTemplates
@@ -61,7 +60,6 @@ set(MVaultSource
     VaultRecordSet.cpp
 
     Functions/CsvParser.cpp
-    Functions/VaultRecordSetOperations.cpp
 )
 
 project(MVault)

diff --git a/Source/Functions/VaultRecordSetOperations.cpp b/Source/Functions/VaultRecordSetOperations.cpp
diff --git a/Source/Functions/VaultRecordSetOperations.h b/Source/Functions/VaultRecordSetOperations.h
diff --git a/Source/MVault.h b/Source/MVault.h
@@ -13,7 +13,6 @@
 #include "Functions/ToString.h"
 #include "Functions/CsvParser.h"
 #include "Functions/PrintAsTable.h"
-#include "Functions/VaultRecordSetOperations.h"
 
 #include "Vault.hpp"
 #include "VaultRequest.hpp"

diff --git a/Source/Vault.h b/Source/Vault.h
@@ -770,6 +770,6 @@ namespace mvlt
         ~Vault() noexcept;
 
         /// Making Intersection function friendly
-        friend void Intersection(const VaultRecordSet& a, const VaultRecordSet& b, VaultRecordSet& res) noexcept;
+        friend VaultOperationResult Intersection(const VaultRecordSet& a, const VaultRecordSet& b, VaultRecordSet& res) noexcept;
     };
 }
diff --git a/Source/VaultRecordSet.cpp b/Source/VaultRecordSet.cpp
@@ -76,7 +76,7 @@ namespace mvlt
         RecursiveReadWriteMtx.Disable();
     }
 
-    VaultRecordSet::VaultRecordSet(const VaultRecordSet& other) noexcept
+    VaultRecordSet::VaultRecordSet(const VaultRecordSet& other) noexcept : Vault()
     {
         if (other.GetIsParentVaultValid())
             CopySet(other);
@@ -340,7 +340,7 @@ namespace mvlt
             res.ResultCode = VaultOperationResultCode::ParentVaultNotMatch;
         }
 
-        if (this == &a)
+        if (res.IsOperationSuccess && this == &a)
         {
             res.IsOperationSuccess = false;
             res.ResultCode = VaultOperationResultCode::SameVaultRecordSetInRequest;
@@ -365,9 +365,37 @@ namespace mvlt
         return res;
     }
 
-    void VaultRecordSet::Exclude(const VaultRecordSet& a) noexcept
+    VaultOperationResult VaultRecordSet::Exclude(const VaultRecordSet& a) noexcept
     {
-        if (GetIsParentVaultValid() && a.GetIsParentVaultValid())
+        VaultOperationResult res;
+        res.IsOperationSuccess = true;
+
+        // Handle errors
+        if (!GetIsParentVaultValid())
+        {
+            res.IsOperationSuccess = false;
+            res.ResultCode = VaultOperationResultCode::ParentVaultNotValid;
+        }
+
+        if (res.IsOperationSuccess && !a.GetIsParentVaultValid())
+        {
+            res.IsOperationSuccess = false;
+            res.ResultCode = VaultOperationResultCode::OtherParentVaultNotValid;
+        }
+
+        if (res.IsOperationSuccess && a.ParentVault != ParentVault)
+        {
+            res.IsOperationSuccess = false;
+            res.ResultCode = VaultOperationResultCode::ParentVaultNotMatch;
+        }
+
+        if (res.IsOperationSuccess && this == &a)
+        {
+            res.IsOperationSuccess = false;
+            res.ResultCode = VaultOperationResultCode::SameVaultRecordSetInRequest;
+        }
+
+        if (res.IsOperationSuccess)
         {
             ReadLock<RecursiveReadWriteMutex> readLock(ParentVault->RecursiveReadWriteMtx);
 
@@ -380,11 +408,41 @@ namespace mvlt
                     ++recordsSetIt;
             }
         }
+
+        return res;
     }
 
-    void VaultRecordSet::Intersect(const VaultRecordSet& a) noexcept
+    VaultOperationResult VaultRecordSet::Intersect(const VaultRecordSet& a) noexcept
     {
-        if (GetIsParentVaultValid() && a.GetIsParentVaultValid())
+        VaultOperationResult res;
+        res.IsOperationSuccess = true;
+
+        // Handle errors
+        if (!GetIsParentVaultValid())
+        {
+            res.IsOperationSuccess = false;
+            res.ResultCode = VaultOperationResultCode::ParentVaultNotValid;
+        }
+
+        if (res.IsOperationSuccess && !a.GetIsParentVaultValid())
+        {
+            res.IsOperationSuccess = false;
+            res.ResultCode = VaultOperationResultCode::OtherParentVaultNotValid;
+        }
+
+        if (res.IsOperationSuccess && a.ParentVault != ParentVault)
+        {
+            res.IsOperationSuccess = false;
+            res.ResultCode = VaultOperationResultCode::ParentVaultNotMatch;
+        }
+
+        if (res.IsOperationSuccess && this == &a)
+        {
+            res.IsOperationSuccess = false;
+            res.ResultCode = VaultOperationResultCode::SameVaultRecordSetInRequest;
+        }
+
+        if (res.IsOperationSuccess)
         {
             ReadLock<RecursiveReadWriteMutex> readLock(ParentVault->RecursiveReadWriteMtx);
 
@@ -397,6 +455,8 @@ namespace mvlt
                     ++recordsSetIt;
             }
         }
+
+        return res;
     }
 
     bool VaultRecordSet::SaveToFile(const std::string& fileName, const std::vector<std::string> keys, const std::string& separator, const bool& isSaveKey) const noexcept
@@ -427,4 +487,109 @@ namespace mvlt
 
         return res;
     }
+
+    VaultOperationResult Union(const VaultRecordSet& a, const VaultRecordSet& b, VaultRecordSet& res) noexcept
+    {
+        VaultOperationResult vor;
+
+        if (&a == &b || &a == &res || &b == &res)
+        {
+            vor.IsOperationSuccess = false;
+            vor.ResultCode = VaultOperationResultCode::SameVaultRecordSetInRequest;
+        }
+        else 
+        {
+            res = a;
+            vor = res.Join(b);
+        }
+
+        return vor;
+    }
+
+    VaultOperationResult Intersection(const VaultRecordSet& a, const VaultRecordSet& b, VaultRecordSet& res) noexcept
+    {
+        VaultOperationResult vor;
+        vor.IsOperationSuccess = true;
+
+        // Handle errors
+        if (&a == &b || &a == &res || &b == &res)
+        {
+            vor.IsOperationSuccess = false;
+            vor.ResultCode = VaultOperationResultCode::SameVaultRecordSetInRequest;
+        }
+
+        if (vor.IsOperationSuccess && !a.GetIsParentVaultValid())
+        {
+            vor.IsOperationSuccess = false;
+            vor.ResultCode = VaultOperationResultCode::ParentVaultNotValid;
+        }
+
+        if (vor.IsOperationSuccess && !b.GetIsParentVaultValid())
+        {
+            vor.IsOperationSuccess = false;
+            vor.ResultCode = VaultOperationResultCode::OtherParentVaultNotValid;
+        }
+
+        if (vor.IsOperationSuccess && a.ParentVault != b.ParentVault)
+        {
+            vor.IsOperationSuccess = false;
+            vor.ResultCode = VaultOperationResultCode::ParentVaultNotMatch;
+        }
+
+        if (vor.IsOperationSuccess)
+        {
+            if (res.GetIsParentVaultValid()) res.Reset();
+
+            a.ParentVault->RecursiveReadWriteMtx.ReadLock();
+
+            res.ParentVault = a.ParentVault;
+
+            for (auto& keyCopierIt : a.VaultKeyCopiers)
+                keyCopierIt.second(&res);
+
+            // Set proper key order
+            res.KeysOrder = a.KeysOrder;
+
+            // Set unique keys
+            res.UniqueKeys = a.UniqueKeys;
+
+            a.ParentVault->RecordSetsSet.emplace(&res);
+
+            // Pick less set to iterate 
+            if (a.RecordsSet.size() < b.RecordsSet.size())
+            {
+                // Iterate over all records in a
+                for (VaultRecord* record : a.RecordsSet)
+                {
+                    // if record in b then add it to the res
+                    if (b.RecordsSet.find(record) != b.RecordsSet.end())
+                    {
+                        res.RecordsSet.emplace(record);
+
+                        for (auto& adder : res.VaultRecordAdders)
+                            adder.second(record);
+                    }
+                }
+            }
+            else 
+            {
+                // Iterate over all records in b
+                for (VaultRecord* record : b.RecordsSet)
+                {
+                    // if record in b then add it to the res
+                    if (a.RecordsSet.find(record) != a.RecordsSet.end())
+                    {
+                        res.RecordsSet.emplace(record);
+
+                        for (auto& adder : res.VaultRecordAdders)
+                            adder.second(record);
+                    }
+                }
+            }
+
+            a.ParentVault->RecursiveReadWriteMtx.ReadUnlock();
+        }
+
+        return vor;
+    }
 }