VaultRecordSet.h

#pragma once
 
#include "Vault.h"
 
namespace mvlt
{
    class VaultRecordSet : protected Vault
    {
    private:
 
        // Pointer to parent Vault
        Vault* ParentVault = nullptr;
 
        template <class T>
        VaultOperationResult RequestRecords(const VaultRequestType& requestType, const std::string& key, const T& beginKeyValue,
            const T& endKeyValue, VaultRecordSet& vaultRecordSet, const bool& isIncludeBeginKeyValue, 
            const bool& isIncludeEndKeyValue, const std::size_t& amountOfRecords, const std::function<bool(const VaultRecordRef&)>& requestPredicat) const noexcept;
 
        std::unordered_set<VaultRecord *>::iterator RemoveRecord(VaultRecord* recordToErase, bool* wasDeleted) noexcept;
 
        void CopySet(const VaultRecordSet& other) noexcept;
 
        void MoveSet(VaultRecordSet& other) noexcept;
 
    public:
 
        friend Vault;
 
        friend VaultRecord;
 
        VaultRecordSet() noexcept;
 
        VaultRecordSet(const VaultRecordSet& other) noexcept;
 
        VaultRecordSet& operator=(const VaultRecordSet& other) noexcept;
 
        VaultRecordSet(VaultRecordSet&& other) noexcept;
 
        VaultRecordSet& operator=(VaultRecordSet&& other) noexcept;
 
        friend bool operator==(const VaultRecordSet& a, const VaultRecordSet& b);
 
        bool GetIsParentVaultValid() const noexcept;
 
        std::string GetParentVaultUniqueId() const noexcept;
    
        bool IsKeyExist(const std::string& key) const noexcept;
 
        template <class T>
        VaultOperationResult GetKeyValue(const std::string& key, T& defaultKeyValue) const noexcept;
 
        bool GetKeyType(const std::string& key, std::type_index& keyType) const noexcept;
 
        VaultOperationResult AddRecord(const VaultRecordRef& recordRef) noexcept;
 
        template <class T>
        VaultOperationResult GetRecord(const std::string& key, const T& keyValue, VaultRecordRef& vaultRecordRef) const noexcept;
 
        template <class T>
        VaultOperationResult GetRecords(const std::string& key, const T& keyValue, std::vector<VaultRecordRef>& recordsRefs, const std::size_t& amountOfRecords = -1) const noexcept;
 
        template <class T>
        VaultOperationResult RequestEqual(const std::string& key, const T& keyValue, VaultRecordSet& vaultRecordSet,
            const std::size_t& amountOfRecords = -1, const std::function<bool(const VaultRecordRef&)>& requestPredicat = DefaultRequestPredicat) const;
 
        template <class T>
        VaultOperationResult RequestGreater(const std::string& key, const T& keyValue, VaultRecordSet& vaultRecordSet,
            const std::size_t& amountOfRecords = -1, const std::function<bool(const VaultRecordRef&)>& requestPredicat = DefaultRequestPredicat) const;
 
        template <class T>
        VaultOperationResult RequestGreaterOrEqual(const std::string& key, const T& keyValue, VaultRecordSet& vaultRecordSet,
            const std::size_t& amountOfRecords = -1, const std::function<bool(const VaultRecordRef&)>& requestPredicat = DefaultRequestPredicat) const;
 
        template <class T>
        VaultOperationResult RequestLess(const std::string& key, const T& keyValue, VaultRecordSet& vaultRecordSet,
            const std::size_t& amountOfRecords = -1, const std::function<bool(const VaultRecordRef&)>& requestPredicat = DefaultRequestPredicat) const;
 
        template <class T>
        VaultOperationResult RequestLessOrEqual(const std::string& key, const T& keyValue, VaultRecordSet& vaultRecordSet,
            const std::size_t& amountOfRecords = -1, const std::function<bool(const VaultRecordRef&)>& requestPredicat = DefaultRequestPredicat) const;
 
        template <class T>
        VaultOperationResult RequestInterval(const std::string& key, const T& beginKeyValue,
            const T& endKeyValue, VaultRecordSet& vaultRecordSet, const bool& isIncludeBeginKeyValue = true, 
            const bool& isIncludeEndKeyValue = true, const std::size_t& amountOfRecords = -1,
            const std::function<bool(const VaultRecordRef&)>& requestPredicat = DefaultRequestPredicat) const;
        
        template <VaultRequestType Type>
        VaultOperationResult Request(const VaultRequest<Type>&& request, VaultRecordSet& vaultRecordSet) const;
 
        bool CheckRecord(const VaultRecordRef& ref) const noexcept;
 
        void Reset() noexcept;
 
        void Clear() noexcept;
 
        bool RemoveRecord(const VaultRecordRef& recordRefToErase) noexcept;
 
        template <class T>
        VaultOperationResult RemoveRecord(const std::string& key, const T& keyValue) noexcept;
 
        template <class T>
        VaultOperationResult RemoveRecords(const std::string& key, const T& keyValue, const std::size_t& amountOfRecords = -1) noexcept;
 
        std::size_t Size() const noexcept;
 
        std::vector<std::string> GetKeys() const noexcept;
 
        std::vector<VaultRecordRef> GetSortedRecords(const std::string& key, const bool& isReverse = false, const std::size_t& amountOfRecords = -1) const noexcept;
 
        template<class F>
        void SortBy(const std::string& key, const F&& func, const bool& isReverse = false, const std::size_t& amountOfRecords = -1) const noexcept;
 
        std::string ToJson(const bool& isFormat = false, const std::size_t& tabSize = 2, const bool& isUseRecordTemplate = true,
            const std::string& recordTemplate = "Record") const noexcept;
 
        void PrintSet(const std::size_t& amountOfRecords = -1) const noexcept;
        
        void PrintAsTable(bool isPrintId = false, const std::size_t& amountOfRecords = -1, std::string primaryKey = "", const bool& isReverse = false,
            const std::list<std::string> keys = {}) const noexcept;
 
        VaultOperationResult Join(const VaultRecordSet& a) noexcept;
 
        VaultOperationResult Exclude(const VaultRecordSet& a) noexcept;
        
        VaultOperationResult Intersect(const VaultRecordSet& a) noexcept;
 
        bool SaveToFile(const std::string& fileName, const std::vector<std::string> keys = {}, const std::string& separator = ",", const bool& isSaveKey = true) const noexcept;
 
        ~VaultRecordSet() noexcept;
 
        friend VaultOperationResult Union(const VaultRecordSet& a, const VaultRecordSet& b, VaultRecordSet& res) noexcept;
 
        friend VaultOperationResult Intersection(const VaultRecordSet& a, const VaultRecordSet& b, VaultRecordSet& res) noexcept;
    };
 
    bool operator==(const VaultRecordSet& a, const VaultRecordSet& b);
 
    VaultOperationResult Union(const VaultRecordSet& a, const VaultRecordSet& b, VaultRecordSet& res) noexcept;
 
    VaultOperationResult Intersection(const VaultRecordSet& a, const VaultRecordSet& b, VaultRecordSet& res) noexcept;
}