Vault.h

#pragma once
 
#include <list>
#include <vector>
#include <functional>
 
#include "VaultClasses.h"
 
#include "Map.h"
#include "VaultRecord.h"
#include "VaultRequest.h"
#include "VaultRecordRef.h"
#include "VaultParamInput.h"
#include "VaultOperationResult.h"
 
#include "Functions/CsvParser.h"
#include "Functions/PrintAsTable.h"
 
namespace mvlt
{
    class Vault
    {
    private:
 
        // Template of data stored inside Vault
        VaultRecord RecordTemplate;
 
        /*
            Hash map to store records
            A string with the name of the key is used as the key. All keys are the same as in Vault.
            The value stores a pointer to std::unordered_multimap<T, VaultRecord*>.
            The key type is same as the Vault key value type.
            The value is a pointer to VaultRecord.
 
            Such a complex structure is needed to quickly, in O(1), search for each key with any type.
        */
        mutable DataHashMap VaultHashMapStructure;
 
        /*
            Map to store records
            A string with the name of the key is used as the key. All keys are the same as in Vault.
            The value stores a pointer to std::multimap<T, VaultRecord*>.
            The key type is same as the Vault key value type.
            The value is a pointer to VaultRecord.
 
            Such a complex structure is necessary in order to quickly, in O(log n), 
            find a set of elements that meet a certain requirement, for example, more than a certain value or less than this value
        */
        mutable DataMap VaultMapStructure;
 
        // Unordered map with keys names and their types
        std::unordered_map<std::string, std::type_index> KeysTypes;
 
        // Unordered_map of functions that add a new element to the VaultStructureHashMap
        std::unordered_map<std::string, std::function<bool(VaultRecord*)>> VaultRecordAdders;
 
        // Unordered_map of functions which clean up the Vault structure, but do not delete records
        std::unordered_map<std::string, std::function<void()>> VaultRecordClearers;
 
        // Unordered_map of functions that erase record from the unordered_map's
        std::unordered_map<std::string, std::function<void(VaultRecord* newRecord)>> VaultRecordErasers;
 
        // Unordered_map of functions for getting sorted data.
        // The key is a string with the name of the key from the Vault.
        // The std::function is used as the value, in which the lambda function is written at the time of adding the key.
        // Lambda accepts a function that is called for each record inside. VaultRecordRef and Vault pointer is passed to it. 
        // By default, iteration by records occurs in ascending order. 
        // isReverse parameter is used for the reverse order.
        std::unordered_map<std::string, std::function<void( std::function<bool(const VaultRecordRef&)> functionToSortedData, Vault* vltPtr, bool isReverse )>> VaultRecordSorters;
 
        // Unordered_map of functions that copy keys from this to VaultRecordSet
        std::unordered_map<std::string, std::function<void(Vault* vaultRecordSet)>> VaultKeyCopiers;
 
        // List to store keys order
        std::list<std::string> KeysOrder;
 
        // Set with all unique keys
        std::set<std::string> UniqueKeys;
 
        // Vector with all invalid records in last readed file
        std::vector<std::pair<std::size_t, std::string>> InvalidFileRecords;
 
        // Recursive mutex for thread safety
        mutable RecursiveReadWriteMutex RecursiveReadWriteMtx;
    protected:
 
        enum class VaultDerivedClasses
        {
            VaultBase,            
            VaultRecordSetDerived 
        };
 
        VaultDerivedClasses VaultDerivedClass;
 
        std::unordered_set<VaultRecord*> RecordsSet;
 
        mutable std::unordered_set<VaultRecordSet*> RecordSetsSet;
 
        template <class T>
        VaultOperationResult SetDataToRecord(VaultRecord* dataRecord, const std::string& key, const T& data) noexcept;
        
        std::unordered_set<VaultRecord *>::iterator RemoveRecord(VaultRecord* recordToErase, bool* wasDeleted) noexcept;
 
        template <class T>
        VaultOperationResult RequestRecordsSet(const VaultRequestType& requestType, const std::string& key, const T& beginKeyValue,
            const T& endKeyValue, std::unordered_set<VaultRecord*>& recordsSet, const bool& isIncludeBeginKeyValue, 
            const bool& isIncludeEndKeyValue, const std::size_t& amountOfRecords, const std::function<bool(const VaultRecordRef&)>& requestPredicat) const noexcept;
 
        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;
 
        template <class T>
        VaultOperationResult AddKey(const std::string& key, const T& defaultKeyValue, const bool& isUniqueKey, const bool& isUniqueKeyWithoutLambda,
            std::function<T(std::size_t, const VaultRecordRef&)> uniqueKeyFunction) noexcept;
 
        bool ReadFile(const std::string& fileName, const bool& isPreprocessRecord, std::function<void (const std::vector<std::string>&, std::vector<std::string>&)> recordHandler, 
            const char& separator, const bool& isLoadKeys, const std::vector<std::string> userKeys) noexcept;
 
    public:
 
        friend VaultRecordRef;
 
        friend VaultRecordSet;
 
        template <VaultRequestType Type>
        friend class VaultRequest;
 
        friend bool operator==(const VaultRecordSet& a, const VaultRecordSet& b);
 
        Vault() noexcept;
 
        Vault(const Vault& other) noexcept;
 
        Vault& operator=(const Vault& other) noexcept;
 
        Vault(Vault&& other) noexcept;
 
        Vault& operator=(Vault&& other) noexcept;
 
        template <class T>
        bool AddKey(const std::string& key, const T& defaultKeyValue) noexcept;
 
        template <class T>
        VaultOperationResult AddUniqueKey(const std::string& key) noexcept;
 
        template <class T>
        VaultOperationResult AddUniqueKey(const std::string& key, std::function<T(std::size_t, const VaultRecordRef&)> uniqueKeyFunction) noexcept;
 
        template <class T>
        VaultOperationResult UpdateKey(const std::string& key, const T& defaultKeyValue) 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;
 
        std::vector<std::string> GetKeys() const noexcept;
 
        std::vector<std::string> GetUniqueKeys() const noexcept;
 
        bool RemoveKey(const std::string& key) noexcept;
 
        VaultOperationResult CreateRecord(const std::vector<std::pair<std::string, VaultParamInput>>& params) noexcept;
 
        VaultOperationResult CreateRecord(VaultRecordRef& vaultRecordRef, const std::vector<std::pair<std::string, VaultParamInput>>& params) 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 noexcept;
 
        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 noexcept;
 
        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 noexcept;
 
        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 noexcept;
 
        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 noexcept;
 
        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 noexcept;
 
        template <VaultRequestType Type>
        VaultOperationResult Request(const VaultRequest<Type>&& request, VaultRecordSet& vaultRecordSet) const;
 
        void DropVault() noexcept;
 
        void DropData() noexcept;
 
        bool EraseRecord(const VaultRecordRef& recordRefToErase) noexcept;
 
        template <class T>
        VaultOperationResult EraseRecord(const std::string& key, const T& keyValue) noexcept;
 
        template <class T>
        VaultOperationResult EraseRecords(const std::string& key, const T& keyValue, const std::size_t& amountOfRecords = -1) noexcept;
 
        std::size_t Size() 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 PrintVault(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;
 
        bool SaveToFile(const std::string& fileName, const std::vector<std::string> keys = {}, const std::string& separator = ",", const bool& isSaveKey = true) const noexcept;
 
        bool ReadFile(const std::string& fileName, const char& separator = ',', const bool& isLoadKeys = true, const std::vector<std::string> keys = {}) noexcept;
 
        bool ReadFile(const std::string& fileName, const char& separator, const bool& isLoadKeys, std::function<void (const std::vector<std::string>&, std::vector<std::string>&)> recordHandler) noexcept;
 
        std::vector<std::pair<std::size_t, std::string>> GetErrorsInLastReadedFile() const noexcept;
 
        ~Vault() noexcept;
 
        friend VaultOperationResult Intersection(const VaultRecordSet& a, const VaultRecordSet& b, VaultRecordSet& res) noexcept;
    };
}