moved InternalFileHierarchyStorage to separate file. Fixed loading/saving infrastructure (not working yet)

libretroshare/src/file_sharing/dir_hierarchy.h

@@ -0,0 +1,119 @@
+#pragma once
+
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include "directory_storage.h"
+
+class InternalFileHierarchyStorage
+{
+public:
+    class FileStorageNode
+    {
+    public:
+        static const uint32_t TYPE_UNKNOWN = 0x0000 ;
+        static const uint32_t TYPE_FILE    = 0x0001 ;
+        static const uint32_t TYPE_DIR     = 0x0002 ;
+
+        virtual ~FileStorageNode() {}
+        virtual uint32_t type() const =0;
+
+        DirectoryStorage::EntryIndex parent_index;
+        uint32_t row ;
+    };
+    class FileEntry: public FileStorageNode
+    {
+    public:
+        FileEntry(const std::string& name,uint64_t size,time_t modtime) : file_name(name),file_size(size),file_modtime(modtime) {}
+        virtual uint32_t type() const { return FileStorageNode::TYPE_FILE ; }
+        virtual ~FileEntry() {}
+
+        // local stuff
+        std::string file_name ;
+        uint64_t    file_size ;
+        time_t      file_modtime;
+        RsFileHash  file_hash ;
+    };
+
+    class DirEntry: public FileStorageNode
+    {
+    public:
+        DirEntry(const std::string& name) : dir_name(name), dir_modtime(0),most_recent_time(0),dir_update_time(0) {}
+        virtual ~DirEntry() {}
+
+        virtual uint32_t type() const { return FileStorageNode::TYPE_DIR ; }
+
+        // local stuff
+        std::string dir_name ;
+        std::string dir_parent_path ;
+
+        std::vector<DirectoryStorage::EntryIndex> subdirs ;
+        std::vector<DirectoryStorage::EntryIndex> subfiles ;
+
+        time_t dir_modtime;
+        time_t most_recent_time;	// recursive most recent modification time, including files and subdirs in the entire hierarchy below.
+        time_t dir_update_time;		// last time the information was updated for that directory. Includes subdirs indexes and subfile info.
+    };
+
+    // class stuff
+    InternalFileHierarchyStorage() ;
+
+    bool load(const std::string& fname) ;
+    bool save(const std::string& fname) ;
+
+    int parentRow(DirectoryStorage::EntryIndex e);
+    bool isIndexValid(DirectoryStorage::EntryIndex e) const;
+    bool stampDirectory(const DirectoryStorage::EntryIndex& indx);
+    bool updateSubDirectoryList(const DirectoryStorage::EntryIndex& indx,const std::map<std::string,time_t>& subdirs);
+    bool removeDirectory(DirectoryStorage::EntryIndex indx)	;
+    bool checkIndex(DirectoryStorage::EntryIndex indx,uint8_t type) const;
+    bool updateSubFilesList(const DirectoryStorage::EntryIndex& indx,const std::map<std::string,DirectoryStorage::FileTS>& subfiles,std::map<std::string,DirectoryStorage::FileTS>& new_files);
+    bool updateHash(const DirectoryStorage::EntryIndex& file_index,const RsFileHash& hash);
+    bool updateFile(const DirectoryStorage::EntryIndex& file_index,const RsFileHash& hash, const std::string& fname,uint64_t size, const time_t modf_time);
+    bool updateDirEntry(const DirectoryStorage::EntryIndex& indx,const std::string& dir_name,time_t most_recent_time,time_t dir_modtime,const std::vector<DirectoryStorage::EntryIndex>& subdirs_array,const std::vector<DirectoryStorage::EntryIndex>& subfiles_array);
+    bool getDirUpdateTS(const DirectoryStorage::EntryIndex& index,time_t& recurs_max_modf_TS,time_t& local_update_TS);
+    bool setDirUpdateTS(const DirectoryStorage::EntryIndex& index,time_t& recurs_max_modf_TS,time_t& local_update_TS);
+
+    // Do a complete recursive sweep over sub-directories and files, and update the lst modf TS. This could be also performed by a cleanup method.
+
+    time_t recursUpdateLastModfTime(const DirectoryStorage::EntryIndex& dir_index);
+
+    // file/dir access and modification
+    bool findSubDirectory(DirectoryStorage::EntryIndex e,const std::string& s) const ;	// returns true when s is the name of a sub-directory in the given entry e
+
+    uint32_t mRoot ;
+    std::vector<FileStorageNode*> mNodes;// uses pointers to keep information about valid/invalid objects.
+
+    void compress() ;					// use empty space in the vector, mostly due to deleted entries. This is a complicated operation, mostly due to
+                                            // all the indirections used. Nodes need to be moved, renamed, etc. The operation discards all file entries that
+                                            // are not referenced.
+
+    friend class DirectoryStorage ;		// only class that can use this.
+    friend class LocalDirectoryStorage ;		// only class that can use this.
+
+    // Low level stuff. Should normally not be used externally.
+
+    const FileStorageNode *getNode(DirectoryStorage::EntryIndex indx) const;
+    const DirEntry *getDirEntry(DirectoryStorage::EntryIndex indx) const;
+    const FileEntry *getFileEntry(DirectoryStorage::EntryIndex indx) const;
+    uint32_t getType(DirectoryStorage::EntryIndex indx) const;
+    DirectoryStorage::EntryIndex getSubFileIndex(DirectoryStorage::EntryIndex parent_index,uint32_t file_tab_index);
+    DirectoryStorage::EntryIndex getSubDirIndex(DirectoryStorage::EntryIndex parent_index,uint32_t dir_tab_index);
+    bool searchHash(const RsFileHash& hash,std::list<DirectoryStorage::EntryIndex>& results);
+
+    bool check(std::string& error_string) const	;// checks consistency of storage.
+
+    void print() const;
+
+private:
+    void recursPrint(int depth,DirectoryStorage::EntryIndex node) const;
+    static bool nodeAccessError(const std::string& s);
+
+    // Removes the given subdirectory from the parent node and all its pendign subdirs. Files are kept, and will go during the cleaning
+    // phase. That allows to keep file information when moving them around.
+
+    bool recursRemoveDirectory(DirectoryStorage::EntryIndex dir);
+
+    std::map<RsFileHash,DirectoryStorage::EntryIndex> mHashes ; // used for fast search access. We should try something faster than std::map. hash_map??
+};