FSNode.hpp

Go to the documentation of this file.

#include <etk/types.hpp>

#pragma once

#include <etk/os/FSNodeRight.hpp>
#define MAX_FILE_NAME      (10240)

//http://developer.android.com/guide/topics/data/data-storage.html


#ifdef __TARGET_OS__Android
    #define HAVE_ZIP_DATA
#endif

#ifdef __TARGET_OS__Windows
    #define HAVE_ZIP_DATA
#endif


#ifdef HAVE_ZIP_DATA
namespace etk {
    class ArchiveContent;
}
#endif
namespace etk {
    void setArgZero(const std::string& _val);
    std::string simplifyPath(std::string _input);
    std::string FSNodeGetApplicationName();
    enum typeNode {
        typeNode_unknow, 
        typeNode_block, 
        typeNode_character, 
        typeNode_folder, 
        typeNode_fifo, 
        typeNode_link, 
        typeNode_file, 
        typeNode_socket, 
    };
    std::ostream& operator <<(std::ostream &_os, const enum etk::typeNode &_obj);
    enum seekNode{
        seekNode_start, 
        seekNode_end, 
        seekNode_current, 
    };
    enum FSNType {
        FSNType_unknow, 
        // user might done abstraction ==> acces of the sdcard when possible ...
        FSNType_direct, 
        FSNType_relatif, 
        
        // depend on case
        //     - PC      : ~/
        //     - Android : /sdcard/
        //     - Apple   : ????
        FSNType_home, 
        
        // depend of the case
        //     - PC      : /usr/shared/programName/
        //     - Android : Internal at the executable file (pointer on static area)
        //     - Apple   : Internal at the executable file
        FSNType_data, 
        
        // depend on case
        //     - PC      : ~/.local/programName/
        //     - Android : /data/data/programName/files/
        //     - Apple   : ????
        FSNType_userData, 
        
        // depend on case
        //     - PC      : ~/.programName/cache/
        //     - Android : /data/data/programName/cache/
        //     - Apple   : ????
        FSNType_cache, 
        
        // depend on case
        //     - try on USER_DATA:/theme/themeName/xxx
        //     - try on DATA:/theme/themeName/xxx
        //     and jump to the default theme file
        //     - try on USER_DATA:/theme/default/xxx
        //     - try on DATA:/theme/default/xxx
        FSNType_theme, 
        FSNType_themeData 
    };
    std::ostream& operator <<(std::ostream &_os, const enum etk::FSNType &_obj);
    
    /*
    note : The filename can be
        Direct mode:
            DIRECT:/sdfsdfsdf/
            /XX ==> for Linux / Mac / Android
            [a-zA-Z]:/xxx ==> for Windows
        
        Data mode:
            DATA:folder/File.ccc
            {libName}DATA:folder/File.ccc ==> try to read in appl data and in next in "libName" lib data folder
            {@libName}DATA:folder/File.ccc ==> try to read ONLY in "libName" lib data folder
        
        User data mode:
            USERDATA:folder/File.ccc
            {libName}USERDATA:folder/File.ccc
            {@libName}USERDATA:folder/File.ccc
        
        Cache Data:
            CACHE:folder/File.ccc
        
        Theme data:
            THEME:folder/file.xxx
            THEME:GUI:folder/file.xxx
            {libName}THEME:GUI:folder/file.xxx
            {@libName}THEME:GUI:folder/file.xxx
        
        Get the root folder:
            ROOT:
            /
            [a-zA-Z]: ==> create more risk ...
        
        Get the Home folder:
            HOME:
            ~
        
        Get the relative folder:
            REL:
            ./
    */
    class FSNode {
        private:
            std::string m_libSearch; 
            std::string m_userFileName; 
            std::string m_systemFileName; 
            enum FSNType m_type; 
            enum typeNode m_typeNode; 
            etk::FSNodeRight m_rights; 
            // specific when file Access :
            FILE * m_PointerFile; 
            uint64_t m_timeCreate; 
            uint64_t m_timeModify; 
            uint64_t m_timeAccess; 
            uint32_t m_idOwner; 
            uint32_t m_idGroup; 
        public:
            FSNode(const std::string& _path = "~");
            #if __CPP_VERSION__ >= 2011
                FSNode(const std::u32string& _path);
            #endif

            ~FSNode();
        private:
            void generateFileSystemPath();
            void updateFileSystemProperty();
            void privateSetName(std::string _newName);
            #if __CPP_VERSION__ >= 2011
                void privateSetName(const std::u32string& _newName);
            #endif
        private:
            #ifdef HAVE_ZIP_DATA

                bool loadDataZip();
                const etk::ArchiveContent* m_zipContent;
                int32_t m_zipReadingOffset;
            #endif
        public:
            bool exist() const {
                return (m_typeNode!=etk::typeNode_unknow);
            };
            enum typeNode getNodeType() const {
                return m_typeNode;
            };
            etk::FSNodeRight getRight() const {
                return m_rights;
            };
            bool setRight(etk::FSNodeRight _newRight);
            void setName(const std::string& _newName);
            #if __CPP_VERSION__ >= 2011
                void setName(const std::u32string& _newName);
            #endif

            std::string getFileSystemName() const;
            #if __CPP_VERSION__ >= 2011
                std::u32string getUFileSystemName() const;
            #endif

            std::string getNameFolder() const;
            #if __CPP_VERSION__ >= 2011
                std::u32string getUNameFolder() const;
            #endif

            std::string getName() const;
            #if __CPP_VERSION__ >= 2011
                std::u32string getUName() const;
            #endif

            std::string getNameFile() const;
            #if __CPP_VERSION__ >= 2011
                std::u32string getUNameFile() const;
            #endif

            std::string getRelativeFolder() const;
            #if __CPP_VERSION__ >= 2011
                std::u32string getURelativeFolder() const;
            #endif

            bool touch();
            bool move(const std::string& _path);
            #if __CPP_VERSION__ >= 2011
                bool move(const std::u32string& _path);
            #endif

            enum FSNType getTypeAccess() const {
                return m_type;
            };
            bool remove();
            uint64_t timeCreated() const;
            std::string timeCreatedString() const;
            #if __CPP_VERSION__ >= 2011
                std::u32string timeUCreatedString() const;
            #endif

            uint64_t timeModified() const;
            std::string timeModifiedString() const;
            #if __CPP_VERSION__ >= 2011
                std::u32string timeUModifiedString() const;
            #endif

            uint64_t timeAccessed() const;
            std::string timeAccessedString() const;
            #if __CPP_VERSION__ >= 2011
                std::u32string timeUAccessedString() const;
            #endif

            const etk::FSNode& operator= (const etk::FSNode &_obj );
            bool operator== (const etk::FSNode &_obj ) const;
            bool operator!= (const etk::FSNode &_obj ) const;
            friend std::ostream& operator <<( std::ostream &_os,const etk::FSNode &_obj);
            
            int64_t folderCount();
            std::vector<etk::FSNode*> folderGetSubList(bool _showHidenFile = true,
                                                       bool _getFolderAndOther = true,
                                                       bool _getFile = true,
                                                       bool _temporaryFile = true);
            std::vector<etk::FSNode*> folderGetSubList(bool _showHidenFile = true,
                                                       bool _getFolderAndOther = true,
                                                       bool _getFile = true,
                                                       const std::string& _filter = ".*");
            std::vector<std::string> folderGetSub(bool _getFolder, bool _getFile, const std::string& _filter);
            etk::FSNode folderGetParent();
            void folderGetRecursiveFiles(std::vector<std::string>& _output, bool _recursiveEnable=true);
            #if __CPP_VERSION__ >= 2011
                void folderGetRecursiveFiles(std::vector<std::u32string>& _output, bool _recursiveEnable=true);
            #endif

            bool fileHasExtention();
            std::string fileGetExtention();
            #if __CPP_VERSION__ >= 2011
                std::u32string fileUGetExtention();
            #endif

            uint64_t fileSize();
            bool fileOpenRead();
            bool fileOpenWrite();
            bool fileOpenAppend();
            bool fileIsOpen();
            bool fileClose();
            char* fileGets(char* _elementLine, int64_t _maxData);
            char fileGet();
            bool fileGets(std::string& _output);
            bool filePut(char _input);
            bool filePuts(const std::string& _input);
            int64_t fileRead(void* _data, int64_t _blockSize, int64_t _nbBlock);
            int64_t fileWrite(const void* _data, int64_t _blockSize, int64_t _nbBlock);
            // TODO: etk::FSNode& operator<< (const std::ostream& _data);
            etk::FSNode& operator<< (const std::stringstream& _data);
            etk::FSNode& operator<< (const std::string& _data);
            etk::FSNode& operator<< (const char* _data);
            etk::FSNode& operator<< (const int32_t _data);
            etk::FSNode& operator<< (const uint32_t _data);
            etk::FSNode& operator<< (const float _data);
            int64_t fileTell();
            bool fileSeek(long int _offset, enum etk::seekNode _origin);
            void fileFlush();
            template<typename T> std::vector<T> fileReadAll() {
                std::vector<T> value;
                value.resize(fileSize());
                fileRead(&value[0], sizeof(T), fileSize()/sizeof(T));
                return value;
            }
            std::string fileReadAllString() {
                std::string value;
                value.resize(fileSize());
                fileRead(&value[0], sizeof(char), fileSize()/sizeof(char));
                return value;
            }
            #if __CPP_VERSION__ >= 2011
            std::u32string fileReadAllU32String() {
                return utf8::convertUnicode(fileReadAllString());
            }
            #endif

            template<typename T>
            void fileWriteAll(const std::vector<T>& _value) {
                fileWrite(static_cast<const void*>(&(_value[0])), sizeof(T), _value.size()/sizeof(T));
            }
            void fileWriteAll(const std::string& _value) {
                fileWrite(static_cast<const void*>(&(_value[0])), sizeof(char), _value.size()/sizeof(char));
            }
            #if __CPP_VERSION__ >= 2011
                void fileWriteAll(const std::u32string& _value) {
                    fileWriteAll(u32char::convertToUtf8(_value));
                }
            #endif
        private:
            void sortElementList(std::vector<etk::FSNode *>& _list);
    };
    std::ostream& operator <<(std::ostream &_os, const etk::FSNode &_obj);
    
    void setBaseFolderData(const char* _folder, const char* _applName=nullptr);
    void setBaseFolderDataUser(const char* _folder);
    void setBaseFolderCache(const char* _folder);
    void initDefaultFolder(const char* _applName);
    std::string getUserHomeFolder();
    #if __CPP_VERSION__ >= 2011
        std::u32string getUUserHomeFolder();
    #endif

    std::string getUserRunFolder();
    #if __CPP_VERSION__ >= 2011
        std::u32string getUUserRunFolder();
    #endif
    
    namespace theme {
        // TODO : Add an INIT ...
        void setName(const std::string& _refName, const std::string& _folderName);
        #if __CPP_VERSION__ >= 2011
            void setName(const std::u32string& _refName, const std::u32string& _folderName);
        #endif

        std::string getName(const std::string& _refName);
        #if __CPP_VERSION__ >= 2011
            std::u32string getName(const std::u32string& _refName);
        #endif

        void setNameDefault(const std::string& _refName, const std::string& _folderName);
        #if __CPP_VERSION__ >= 2011
            void setNameDefault(const std::u32string& _refName, const std::u32string& _folderName);
        #endif

        std::string getNameDefault(const std::string& _refName);
        #if __CPP_VERSION__ >= 2011
            std::u32string getNameDefault(const std::u32string& _refName);
        #endif

        std::vector<std::string> list();
        #if __CPP_VERSION__ >= 2011
            std::vector<std::u32string> listU();
        #endif
    };
    
    bool FSNodeRemove(const std::string& _path);
    #if __CPP_VERSION__ >= 2011
        bool FSNodeRemove(const std::u32string& _path);
    #endif

    int64_t FSNodeGetCount(const std::string& _path);
    #if __CPP_VERSION__ >= 2011
        int64_t FSNodeGetCount(const std::u32string& _path);
    #endif

    bool FSNodeCreate(const std::string& _path, etk::FSNodeRight _right, enum etk::typeNode _type=etk::typeNode_folder);
    #if __CPP_VERSION__ >= 2011
        bool FSNodeCreate(const std::u32string& _path, etk::FSNodeRight _right, enum etk::typeNode _type=etk::typeNode_folder);
    #endif

    bool FSNodeExist(const std::string& _path);
    #if __CPP_VERSION__ >= 2011
        bool FSNodeExist(const std::u32string& _path);
    #endif

    bool FSNodeMove(const std::string& _path1, const std::string& _path2);
    #if __CPP_VERSION__ >= 2011
        bool FSNodeMove(const std::u32string& _path1, const std::u32string& _path2);
    #endif

    etk::FSNodeRight FSNodeGetRight(const std::string& _path);
    #if __CPP_VERSION__ >= 2011
        etk::FSNodeRight FSNodeGetRight(const std::u32string& _path);
    #endif

    enum etk::typeNode FSNodeGetType(const std::string& _path);
    #if __CPP_VERSION__ >= 2011
        enum etk::typeNode FSNodeGetType(const std::u32string& _path);
    #endif

    uint64_t FSNodeGetTimeCreated(const std::string& _path);
    #if __CPP_VERSION__ >= 2011
        uint64_t FSNodeGetTimeCreated(const std::u32string& _path);
    #endif

    uint64_t FSNodeGetTimeModified(const std::string& _path);
    #if __CPP_VERSION__ >= 2011
        uint64_t FSNodeGetTimeModified(const std::u32string& _path);
    #endif

    uint64_t FSNodeGetTimeAccessed(const std::string& _path);
    #if __CPP_VERSION__ >= 2011
        uint64_t FSNodeGetTimeAccessed(const std::u32string& _path);
    #endif

    bool FSNodeTouch(const std::string& _path);
    #if __CPP_VERSION__ >= 2011
        bool FSNodeTouch(const std::u32string& _path);
    #endif

    bool FSNodeEcho(const std::string& _path, const std::string& _dataTowrite);
    #if __CPP_VERSION__ >= 2011
        bool FSNodeEcho(const std::u32string& _path, const std::u32string& _dataTowrite);
    #endif

    bool FSNodeEchoAdd(const std::string& _path, const std::string& _dataTowrite);
    #if __CPP_VERSION__ >= 2011
        bool FSNodeEchoAdd(const std::u32string& _path, const std::u32string& _dataTowrite);
    #endif

    void FSNodeHistory(const std::string& _path, int32_t _historyCount);
    #if __CPP_VERSION__ >= 2011
        void FSNodeHistory(const std::u32string& _path, int32_t _historyCount);
    #endif

    std::string FSNodeReadAllData(const std::string& _path);
    void FSNodeWriteAllData(const std::string& _path, const std::string& _data);
    template<typename TTT> std::vector<TTT> FSNodeReadAllDataType(const std::string& _path) {
        std::vector<TTT> out;
        etk::FSNode node(_path);
        if (node.fileOpenRead() == false) {
            //TK_ERROR("can not open file : '" << node << "'");
            return out;
        }
        uint64_t nbByte = node.fileSize();
        out.resize(nbByte/sizeof(TTT));
        if (out.size()*sizeof(TTT) != nbByte) {
            //TK_WARNING("Error in reading the file missing some byte at the end ...");
        }
        node.fileRead(&out[0], sizeof(TTT), nbByte/sizeof(TTT));
        node.fileClose();
        return out;
    }
    template<typename TTT> void FSNodeWriteAllDataType(const std::string& _path, const std::vector<TTT>& _data) {
        etk::FSNode node(_path);
        if (node.fileOpenWrite() == false) {
            //TK_ERROR("can not open file : '" << node << "'");
            return;
        }
        node.fileWrite(&_data[0], sizeof(TTT), _data.size());
        node.fileClose();
    }
    std::string FSNodeGetRealName(const std::string& _path);
    
    std::vector<std::string> FSNodeExplodeMultiplePath(const std::string& _path);
};