> ./all_tests.sh ============ build lib and test apps ============ g++ -fPIC -std=c++20 -c service/egByteArray.cpp -o service/egByteArray.o g++ -fPIC -std=c++20 -c nodes/egDataNodesType.cpp -o nodes/egDataNodesType.o g++ -fPIC -std=c++20 -c nodes/egDataNodesLocalFile.cpp -o nodes/egDataNodesLocalFile.o g++ -fPIC -std=c++20 -c nodes/egDataNodesContainer.cpp -o nodes/egDataNodesContainer.o g++ -fPIC -std=c++20 -c nodes/egDataNodeBlueprint.cpp -o nodes/egDataNodeBlueprint.o g++ -fPIC -std=c++20 -c nodes/egDataNode.cpp -o nodes/egDataNode.o g++ -fPIC -std=c++20 -c indexes/egIndexes.cpp -o indexes/egIndexes.o g++ -fPIC -std=c++20 -c indexes/egIndexConditions.cpp -o indexes/egIndexConditions.o g++ -fPIC -std=c++20 -c indexes/egFingers.cpp -o indexes/egFingers.o g++ -fPIC -std=c++20 -c links/egLinksType.cpp -o links/egLinksType.o g++ -fPIC -std=c++20 -c links/egFlexLinksType.cpp -o links/egFlexLinksType.o g++ -fPIC -std=c++20 -c metainfo/egLayersType.cpp -o metainfo/egLayersType.o g++ -fPIC -std=c++20 -c metainfo/egDatabaseType.cpp -o metainfo/egDatabaseType.o g++ -shared -o libegdb.so service/egByteArray.o nodes/egDataNodesType.o nodes/egDataNodesLocalFile.o nodes/egDataNodesContainer.o nodes/egDataNodeBlueprint.o nodes/egDataNode.o indexes/egIndexes.o indexes/egIndexConditions.o indexes/egFingers.o links/egLinksType.o links/egFlexLinksType.o metainfo/egLayersType.o metainfo/egDatabaseType.o =============== Finished compilation of libegdb.so =============== -rwxrwxr-x 1068760 libegdb.so =============== clean =============== rm -f service/egByteArray.o nodes/egDataNodesType.o nodes/egDataNodesLocalFile.o nodes/egDataNodesContainer.o nodes/egDataNodeBlueprint.o nodes/egDataNode.o indexes/egIndexes.o indexes/egIndexConditions.o indexes/egFingers.o links/egLinksType.o links/egFlexLinksType.o metainfo/egLayersType.o metainfo/egDatabaseType.o g++ -std=c++20 -c tests/testDataNodesLocalFile.cpp -o tests/testDataNodesLocalFile.o g++ tests/testDataNodesLocalFile.o -L. -legdb -o tests/testDataNodesLocalFile.exe g++ -std=c++20 -c tests/testFlexLinks.cpp -o tests/testFlexLinks.o g++ tests/testFlexLinks.o -L. -legdb -o tests/testFlexLinks.exe g++ -std=c++20 -c tests/testGeneralOps.cpp -o tests/testGeneralOps.o g++ tests/testGeneralOps.o -L. -legdb -o tests/testGeneralOps.exe g++ -std=c++20 -c tests/testDataNodesContainer.cpp -o tests/testDataNodesContainer.o g++ tests/testDataNodesContainer.o -L. -legdb -o tests/testDataNodesContainer.exe g++ -std=c++20 -c tests/testIndexesUsage.cpp -o tests/testIndexesUsage.o g++ tests/testIndexesUsage.o -L. -legdb -o tests/testIndexesUsage.exe g++ -std=c++20 -c tests/testDataNodeBlueprint.cpp -o tests/testDataNodeBlueprint.o g++ tests/testDataNodeBlueprint.o -L. -legdb -o tests/testDataNodeBlueprint.exe g++ -std=c++20 -c tests/testFingers.cpp -o tests/testFingers.o g++ tests/testFingers.o -L. -legdb -o tests/testFingers.exe g++ -std=c++20 -c tests/testBasicOps.cpp -o tests/testBasicOps.o g++ tests/testBasicOps.o -L. -legdb -o tests/testBasicOps.exe g++ -std=c++20 -c tests/testLinks.cpp -o tests/testLinks.o g++ tests/testLinks.o -L. -legdb -o tests/testLinks.exe g++ -std=c++20 -c tests/testIndexes.cpp -o tests/testIndexes.o g++ tests/testIndexes.o -L. -legdb -o tests/testIndexes.exe g++ -std=c++20 -c tests/testDataFields.cpp -o tests/testDataFields.o g++ tests/testDataFields.o -L. -legdb -o tests/testDataFields.exe g++ -std=c++20 -c tests/testLayers.cpp -o tests/testLayers.o g++ tests/testLayers.o -L. -legdb -o tests/testLayers.exe tests/testDataNodesLocalFile.exe tests/testFlexLinks.exe tests/testGeneralOps.exe tests/testDataNodesContainer.exe tests/testIndexesUsage.exe tests/testDataNodeBlueprint.exe tests/testFingers.exe tests/testBasicOps.exe tests/testLinks.exe tests/testIndexes.exe tests/testDataFields.exe tests/testLayers.exe =============== Finished compilation of tests =============== rm -f tests/testDataNodesLocalFile.o tests/testFlexLinks.o tests/testGeneralOps.o tests/testDataNodesContainer.o tests/testIndexesUsage.o tests/testDataNodeBlueprint.o tests/testFingers.o tests/testBasicOps.o tests/testLinks.o tests/testIndexes.o tests/testDataFields.o tests/testLayers.o rm -f tests/*.o rm -f *.o ============ run test apps ============ initDatabase() not found metadata storage, create new: egNodesTypesMetainfo initDatabase() not found metadata storage, create new: egLinksTypesMetainfo initDatabase() not found metadata storage, create new: egLayersTypesMetainfo ===== Test basic database ops ===== PASS ===== Test length convertor ( 123456789 ) ===== byteCountIn: 4 byteCountOut: 4 testLength: 123456789 ===== Test hamSlicer ===== PASS ===== Test DataNodeBlueprint (2 errors must appear in negative tests) ===== ERROR: AddIndex() for DataNodeBlueprint: "testNodes" field name "bad index name" not found ERROR: Can't add field "try to add field after commit" to DataNodeBlueprint: "testNodes". Call BlueprintInitStart() first PASS ===== Test NodesContainerType ===== PASS ===== Test egDataNodeLocalFile ===== PASS ===== Test EgFingers Stage 1 ===== PASS ===== Test EgFingers Stage 2 ===== PASS ===== Test EgFreeLinksType ===== PASS ===== Test general database ops ===== PASS ===== Test EgIndexes ===== PASS ===== Test indexes ops ===== PASS ===== Test EgLayersType ===== PASS ===== Test EgLinksType ===== PASS PASS total: 13 FAIL total: 0
#pragma once #include <iostream> #include <fstream> #include <vector> #include "egCoreIndexTypes.h" #include "../service/egByteArray.h" #include "../service/egFileType.h" template <typename KeyType> class EgIndexes; // Finger in the file: KeyMin KeyMax nextChunkOffset isLeaf(root only) // Chunk in the file: FingersArray parentFingerOffset chunkIsLeaf fingersCount template <typename KeyType> class EgFingers { public: // fingers tree (N-M type) part of indexes-fingers complex const egMaxStreamSizeType nextChunkOffsetPosition = sizeof(KeyType) * 2; // + sizeof(keysCountType); const egMaxStreamSizeType oneFingerSize = nextChunkOffsetPosition + sizeof(uint64_t); // last is next chunk offset const egMaxStreamSizeType rootHeaderSize = oneFingerSize + sizeof(uint8_t); // bool isLeaf as uint8_t const egMaxStreamSizeType parentChunkOffsetPosition = egIndexesSpace::egChunkCapacity * oneFingerSize; const egMaxStreamSizeType chunkIsLeafPosition = parentChunkOffsetPosition + sizeof(uint64_t); const egMaxStreamSizeType chunkCountPosition = chunkIsLeafPosition + sizeof(uint8_t); const egMaxStreamSizeType fingersChunkSize = chunkCountPosition + + sizeof(keysCountType); // bool isLeaf as uint8_t const bool isRootFinger = true; // mnemonic const bool notRootFinger = false; // mnemonic bool rootFingerIsLoaded {false}; bool anyMinMaxChanged; std::string fingersFileName; egFinger<KeyType> rootFinger; egFinger<KeyType> parentFinger; egFinger<KeyType> currentFinger; egFinger<KeyType> newFinger; egFinger<KeyType> lastFinger; EgIndexes<KeyType>* indexChunks {nullptr}; // ptr to related indexes object, set by upper IndexesFiles interface class std::vector < egFinger<KeyType> > fingersChain; // store fingers path for update EgFileType fingersFileStream; // file operations EgDataStream* localStream {nullptr}; // chunk buffer operations EgFingers(std::string a_fingersName, EgIndexes<KeyType>* indexChunksPtr); ~EgFingers() { delete localStream; } inline void InitFinger(egFinger<KeyType>& theFinger); // top API bool AddNewRootFinger(KeyType& Key, uint64_t indexesChunkOffset); bool FindIndexesChunkToInsert(KeyType& Key); // sets currentFinger and fingersChain bool UpdateFingersChainUp(); // uses currentFinger and fingersChain bool AddNewUpdateCurrentFinger(); // uses current and new fingers and fingersChain bool DeleteCurrentFingerByChain(); // uses currentFinger and fingersChain bool UpdateFingersByBackptrs(); // uses currentFinger (another index chunk, can't use chain) bool DeleteFingerByBackptrs(); // uses currentFinger (another index chunk, can't use chain) // files bool CheckIfFingerFileExists(){ return fingersFileStream.checkIfExists(); } bool DeleteFingersFile(); // file ops inline bool LoadRootFingerFromFile (egFinger<KeyType>& theFinger, bool loadRootIsLeaf); inline bool StoreFingerToFile (egFinger<KeyType>& theFinger); inline bool LoadFingersChunk (uint64_t& chunkOffset); // to localStream-> bufData inline bool StoreFingersChunk (uint64_t fingersChunkOffset); // from localStream-> bufData inline bool StoreParentChunkOffsetDirect(uint64_t fingersChunkOffset, uint64_t parentChunkOffset); void SwapFingers(); // swaps current and new fingers for finger tests (if new key < current key) // chunk operations inline void ClearFingersChunk (); inline void ReadFingerFromChunk (egFinger<KeyType>& theFinger, const int fingerPositionNum); inline void WriteFingerToChunk (egFinger<KeyType>& theFinger); // QDataStream &localFingersStream, inline void ReadChunkMinMaxToParentFinger (egFinger<KeyType>& theParentFinger); inline bool GetParentFingerByOffset(uint64_t fingersChunkOffset, uint64_t nextOffset); // uses current finger // finger ops inline bool FingerIsRoot(egFinger<KeyType>& theFinger); inline void GetCountFromChunk(keysCountType& refCount); inline void WriteCountToChunk(keysCountType theCount); inline void GetCountDirect(keysCountType& refCount, uint64_t& chunkOffset); inline void GetChunkIsLeaf(uint8_t& isLeaf); inline void UpdateChunkIsLeaf(const uint8_t chunkIsLeaf); inline void GetChunkParentOffset(uint64_t& parentChunkOffset); inline void UpdateChunkParentOffset(uint64_t parentChunkOffset); // insert ops inline bool AppendNewFingersChunk(egFinger<KeyType>& theFinger); inline bool AddNewTopLevelChunk(); // ex AddNewSubRootChunk(); FIXME level number used inline void MoveTailToInsert(egMaxStreamSizeType fingerPositionBytes, egMaxStreamSizeType bytesToMove); inline void SaveLastFingerOfChunk(); inline bool InsertNewFingerToChunk(); // bool replaceLast InsertSplittedFinger(); // int SplitFingersChunk(); // TODO // update ops inline bool UpdateMinMaxByFlags(egFinger<KeyType>& theFinger); // delete ops inline bool DeleteFingerFromChunk(); // uses current and chunk inline bool DeleteFingersChunk(uint64_t fingersChunkOffset); inline bool DeleteTopChunk(); // lookups typedef bool (*CompareFunctionType) (KeyType&, KeyType&); // static bool CompareEQ (KeyType& currentValue, KeyType& key) {return (currentValue == key);} static bool CompareGT (KeyType& currentValue, KeyType& key) {return (currentValue > key);} static bool CompareGE (KeyType& currentValue, KeyType& key) {return (currentValue >= key);} static bool CompareLT (KeyType& currentValue, KeyType& key) {return (currentValue < key);} static bool CompareLE (KeyType& currentValue, KeyType& key) {return (currentValue <= key);} inline bool OpenFileStream(); bool FindIndexChunkEQ(KeyType& Key); // first finger for key greater or equal then finger's min value inline void FindFirstFinger(KeyType& Key, CompareFunctionType predicate); inline void FindLastFinger(KeyType& Key, CompareFunctionType predicate); bool FindIndexChunkLess(KeyType& Key, CompareFunctionType predicate); bool FindIndexChunkLT(KeyType& Key) { return FindIndexChunkLess(Key, CompareGE); } bool FindIndexChunkLE(KeyType& Key) { return FindIndexChunkLess(Key, CompareGT); } bool FindIndexChunkGreater(KeyType& Key, CompareFunctionType predicate); bool FindIndexChunkGE(KeyType& Key) { return FindIndexChunkGreater(Key, CompareLT); } bool FindIndexChunkGT(KeyType& Key) { return FindIndexChunkGreater(Key, CompareLE); } // debug void PrintFingerInfo(egFinger<KeyType>& fingerInfo, const std::string theMessage); };
#pragma once #include <iostream> // debug #include <fstream> #include <set> #include <vector> // #include <experimental/filesystem> #include "egCoreIndexTypes.h" #include "../service/egByteArray.h" #include "../service/egFileType.h" #include "egFingers.h" // template <typename KeyType> class EgFingers; class EgIndexesAbstractType { public: virtual bool AddNewIndex(EgByteArrayAbstractType& keyBA, uint64_t dataOffset) = 0; virtual bool DeleteIndex(EgByteArrayAbstractType& keyBA, uint64_t dataOffset) = 0; virtual bool UpdateDataOffset(EgByteArrayAbstractType& keyBA, uint64_t oldDataOffset, uint64_t newDataOffset) = 0; virtual bool LoadAllDataEQ(std::set<uint64_t>& index_offsets, EgByteArrayAbstractType& keyBA) = 0; virtual bool LoadAllDataGE(std::set<uint64_t>& index_offsets, EgByteArrayAbstractType& keyBA) = 0; virtual bool LoadAllDataGT(std::set<uint64_t>& index_offsets, EgByteArrayAbstractType& keyBA) = 0; virtual bool LoadAllDataLE(std::set<uint64_t>& index_offsets, EgByteArrayAbstractType& keyBA) = 0; virtual bool LoadAllDataLT(std::set<uint64_t>& index_offsets, EgByteArrayAbstractType& keyBA) = 0; virtual ~EgIndexesAbstractType() {} }; template <typename KeyType> class EgIndexes : public EgIndexesAbstractType { public: // indexes chain part of indexes-fingers complex const uint64_t indexHeaderSize = sizeof(uint64_t); const egMaxStreamSizeType oneIndexSize = sizeof(KeyType) + sizeof(uint64_t); // key and data offset const egMaxStreamSizeType fwdPtrPosition = egIndexesSpace::egChunkCapacity * oneIndexSize; const egMaxStreamSizeType backPtrPosition = fwdPtrPosition + sizeof(uint64_t); const egMaxStreamSizeType chunkCountPosition = backPtrPosition + sizeof(uint64_t); const egMaxStreamSizeType fingersChunkOffsetPosition = chunkCountPosition + sizeof(keysCountType); const egMaxStreamSizeType indexChunkSize = fingersChunkOffsetPosition + sizeof(uint64_t); bool fingersChainFlag {true}; KeyType theKey; // index key to process uint64_t theDataOffset; // offsets in data nodes file uint64_t theNewDataOffset; uint64_t theOldDataOffset; keysCountType theChunkCount; // indexes count in the chunk for chain opers uint64_t theIndexesChunkOffset; // file position for chain connect int theIndexPosition; // position in the chunk uint64_t prevOffsetPtr; // chunks chain operations uint64_t nextOffsetPtr; uint64_t currentIndexQuantity; // position savepoint for Load*DataNext functions uint64_t currentChunkOffset; // chunk savepoint for Load*DataNext functions keysCountType transactionPosInChunk; // chunk position savepoint for Load*DataNext functions uint64_t reallyLoaded {0}; // first/next opers support uint64_t transactionID {0}; // FIXME TODO first/next opers support EgFingers<KeyType>* fingersTree {nullptr}; // fingers tree object ptr EgDataStream* localStream {nullptr}; // chunk buffer operations EgIndexStruct<KeyType> indexData; // index data wrapper for flexibility EgFileType indexFileStream; // file operations std::string indexFileName; EgIndexes(const std::string a_indexName); virtual ~EgIndexes() { delete localStream; } // top API bool AddNewIndex(EgByteArrayAbstractType& keyBA, uint64_t dataOffset) override; bool DeleteIndex(EgByteArrayAbstractType& keyBA, uint64_t dataOffset) override ; bool UpdateDataOffset(EgByteArrayAbstractType& keyBA, uint64_t oldDataOffset, uint64_t newDataOffset) override; // load data top API bool LoadAllDataFirst(std::set<uint64_t>& index_offsets, uint64_t& maxQuantity); bool LoadDataNextUp (std::set<uint64_t>& index_offsets, uint64_t& maxQuantity); bool LoadAllDataEQ(std::set<uint64_t>& index_offsets, EgByteArrayAbstractType& keyBA); bool LoadAllDataGE(std::set<uint64_t>& index_offsets, EgByteArrayAbstractType& keyBA); bool LoadAllDataGT(std::set<uint64_t>& index_offsets, EgByteArrayAbstractType& keyBA); bool LoadAllDataLE(std::set<uint64_t>& index_offsets, EgByteArrayAbstractType& keyBA); bool LoadAllDataLT(std::set<uint64_t>& index_offsets, EgByteArrayAbstractType& keyBA); };
graphDB.CreateNodeBlueprint("myDataNodes");
graphDB.AddNodeDataField("name");
graphDB.AddNodeDataField("cornerX");
graphDB.AddNodeDataField("cornerY");
graphDB.CommitNodeBlueprint();
#pragma once #include "../metainfo/egDatabaseType.h" class EgLinksType { public: EgDataNodesType linksDataStorage; EgDataNodesMapType& dataMap; // shortcut to container nodes map, for (auto iter : dataMap) // bool isConnected { false }; // ? TODO nodes data status ( connected, no file, no server) EgBlueprintIDType linkBlueprintID { 0 }; std::string linkTypeName; EgDataNodeBlueprintType* dataNodeBlueprint { nullptr }; // storage shortcut EgDatabaseType* metaInfoDatabase { nullptr }; EgDataNodesContainerType* fromDataNodes { nullptr }; EgDataNodesContainerType* toDataNodes { nullptr }; EgLinksType(): dataMap(linksDataStorage.dataMap) {} ~EgLinksType() { linksDataStorage.clear(); } void clear(); int ConnectLinks(const std::string& linkNameStr, EgDatabaseType& myDB); // check links in database metainfo void AddRawLink(EgDataNodeIDType fromID, EgDataNodeIDType toID); int AddNodeContainersLink(EgDataNodeIDType fromID, EgDataNodeIDType toID); EgLinksType& operator << (EgDataNode* newNode) { linksDataStorage.AddDataNode(newNode); return *this; } EgLinksType& operator << (EgDataNode& newNode) { linksDataStorage.AddDataNode(newNode); return *this; } EgDataNodeIDType getAddedNodeID() {return linksDataStorage.getAddedNodeID();} int LoadLinks(); int StoreLinks(); int AddLinkPtrsToNodes(EgDataNode& link, EgDataNode& from, EgDataNode& to); int ResolveNodesIDsToPtrs(EgDataNodesType& from, EgDataNodesType& to); int MarkUpdatedLink(EgDataNodeIDType linkNodeID) {return linksDataStorage.MarkUpdatedDataNode(linkNodeID);} void DeleteArrowLink(EgDataLinkIDType linkID); void DeleteInLink(EgDataLinkIDType linkID); void DeleteOutLink(EgDataLinkIDType linkID); }; void PrintResolvedLinks(const EgDataNode& node);
#pragma once #include "egDataNodesContainer.h" typedef void (*serialLoadFunctionType) (EgDataNode& dataNode); typedef void (*serialStoreFunctionType) (EgDataNode& dataNode); class EgLinksType; // arrow links class EgDatabaseType; // peer database class EgDataNodesType { // "type" means c++ type, data metatype called "blueprint" public: bool isConnected { false }; // checked blueprint file and central egDb metadata bool isDataLoaded { false }; bool isDataUpdated { false }; std::string dataNodesName; EgDatabaseType* metaInfoDatabase { nullptr }; // nodes and links layout == blueprint == class == type info EgDataNodeBlueprintType* dataNodeBlueprint { nullptr }; // layout == blueprint == class == type of these data nodes EgDataNodesContainerType* nodesContainer { nullptr }; // data storage of all these nodes EgDataNodesMapType& dataMap; // shortcut to container nodes map, for (auto iter : dataMap) serialLoadFunctionType serialLoadFunction { nullptr }; // function for automated data load from node to void* localDataPtr serialStoreFunctionType serialStoreFunction { nullptr }; // function for automated data store to node form void* localDataPtr EgDataNodesType(); ~EgDataNodesType() { clear(); delete dataNodeBlueprint; delete nodesContainer; } void clear(); int ConnectSystemNodeType(std::string a_dataNodesName); // for local testing or internal database storages int OpenLocalBlueprint(); int Connect(const std::string& nodesNameStr, EgDatabaseType& myDB); int AddDataNode(EgDataNode* newNode); int AddDataNode(EgDataNode& newNode) { return AddDataNode(&newNode); } EgDataNodesType& operator << (EgDataNode* newNode) { AddDataNode(newNode); return *this; } EgDataNodesType& operator << (EgDataNode& newNode) { AddDataNode(newNode); return *this; } EgDataNodeIDType getAddedNodeID() { return nodesContainer->lastNodeID; } int MarkUpdatedDataNode(EgDataNodeIDType nodeID); int MarkUpdatedDataNode(EgDataNode& updNode) { return MarkUpdatedDataNode(updNode.dataNodeID); } void DeleteDataNode(EgDataNodeIDType delID); void DeleteDataNode(EgDataNode& delNode) { return DeleteDataNode(delNode.dataNodeID); } int Store(); int LoadAllNodes(); bool LoadNodesEQ(const std::string& indexName, EgByteArrayAbstractType& fieldValue); // Projects.LoadIndexedNodes(IC<int>("owner", EQ, 2) && IC<int>("status", EQ, 3)); // int LoadNodesByOffsets() { return nodesContainer-> LoadLocalNodesByOffsets(indexOffsets); } EgDataNode& operator[](EgDataNodeIDType nodeID); };
#pragma once #include "../indexes/egCoreIndexTypes.h" #include "../service/egByteArray.h" #include "../service/egFileType.h" const int egBlueprintInit {1}; // int blueprintMode const int egBlueprintActive {2}; class EgDataNodeBlueprintType { public: int blueprintMode {egBlueprintActive}; // blueprint can't be edited freely, data pumping on changes is required EgBlueprintIDType blueprintID; // Data Nodes Blueprint (DNL) ID for graph DB std::string blueprintName; // == dataNodesTypeName EgHamSlicerType theHamSlicer; // memory allocator for data nodes (node has only blueprint out connect) EgFileType blueprintFile; // local files load & store support (if local files used) // EgNodeBlueprintSettingsType blueprintSettings; // add-ons for blueprint type EgFieldsCountType fieldsCount {0}; std::unordered_map < std::string, EgFieldsCountType > dataFieldsNames; // map data node field names to fields indexes for dataFieldsPtrs std::unordered_map < std::string, EgIndexSettingsType > indexedFields; EgByteArrayAbstractType egNotFound; const char* egNotFoundStr {"<Data Not Found>"}; EgDataNodeBlueprintType(std::string a_blueprintName): blueprintName(a_blueprintName), blueprintFile(a_blueprintName) { egNotFound.dataSize = strlen(egNotFoundStr)+1; egNotFound.dataChunk = (unsigned char *) egNotFoundStr; } ~EgDataNodeBlueprintType() { /* std::cout << "EgDataNodeBlueprintType destructor " << std::endl; */ clear(); } void clear() { dataFieldsNames.clear(); indexedFields.clear(); } int BlueprintInitStart(); void AddDataFieldName(std::string fieldName); void AddIndex(std::string indexName, uint8_t indexSizeBytes = 4, uint8_t indexSubType = egIndexesSpace::egIntFT); // default int32 void BlueprintInitCommit(); bool isIndexedField(std::string& name); inline void writeDataFieldsNames(); inline void readDataFieldsNames(); inline void writeIndexedFields(); inline void readIndexesFields(); int LocalStoreBlueprint(); int LocalLoadBlueprint(); }; // ======================== Debug ======================== void PrintDataNodeBlueprint(EgDataNodeBlueprintType& blueprint);
#pragma once #include <iostream> #include <cstdint> #include <map> #include <unordered_map> typedef unsigned char ByteType; // ID types typedef uint32_t EgDataNodeIDType; typedef EgDataNodeIDType EgDataLinkIDType; typedef uint16_t EgBlueprintIDType; // data nodes and links blueprint/layout/type/class ID type typedef uint16_t EgLayerNumType; // count/size/length types typedef uint16_t EgFieldNameLengthType; typedef uint8_t EgFieldsCountType; typedef uint16_t EgStrSizeType; typedef uint64_t StaticLengthType; // map types class EgDataNode; class EgDataLinkType; typedef std::unordered_map <EgDataNodeIDType, EgDataNode*> EgDataNodesMapType; typedef std::map <EgDataNodeIDType, EgDataNode*> EgDataNodesOrdMapType; typedef std::unordered_map <EgDataLinkIDType, EgDataNode*> EgLinkIDsNodePtrsMapType; typedef std::unordered_map <EgDataNode*, EgDataNode*> EgLinkDataPtrsNodePtrsMapType; const uint64_t egDefaultHamBrickSize = 1024;
![[personal profile]](https://www.dreamwidth.org/img/silk/identity/user.png){kind=small}
branchandroot