file_system.h

Go to the documentation of this file.

/*
 *  Copyright (c) 2000-2022 Inria
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 *  * Redistributions of source code must retain the above copyright notice,
 *  this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright notice,
 *  this list of conditions and the following disclaimer in the documentation
 *  and/or other materials provided with the distribution.
 *  * Neither the name of the ALICE Project-Team nor the names of its
 *  contributors may be used to endorse or promote products derived from this
 *  software without specific prior written permission.
 * 
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 *  POSSIBILITY OF SUCH DAMAGE.
 *
 *  Contact: Bruno Levy
 *
 *     https://www.inria.fr/fr/bruno-levy
 *
 *     Inria,
 *     Domaine de Voluceau,
 *     78150 Le Chesnay - Rocquencourt
 *     FRANCE
 *
 */
 
#ifndef GEOGRAM_BASIC_FILE_SYSTEM
#define GEOGRAM_BASIC_FILE_SYSTEM
 
#include <geogram/basic/common.h>
#include <geogram/basic/numeric.h>
#include <geogram/basic/counted.h>
#include <geogram/basic/smart_pointer.h>
 
#include <string>
#include <vector>
#include <map>
 
namespace GEO {
 
    namespace FileSystem {
 
        class GEOGRAM_API Node : public Counted {
        public:
            Node();
            
            ~Node() override;
 
            /************************** OS-dependent **************************/
            
            virtual bool is_file(const std::string& path);
 
            virtual bool is_directory(const std::string& path);
 
            virtual bool create_directory(const std::string& path);
 
            virtual bool delete_directory(const std::string& path);
 
            virtual bool delete_file(const std::string& path);
 
            virtual bool get_directory_entries(
                const std::string& path, std::vector<std::string>& result
            );
 
            virtual std::string get_current_working_directory();
 
            virtual bool set_current_working_directory(
                const std::string& path
            );
 
            virtual bool rename_file(
                const std::string& old_name, const std::string& new_name
            );
 
            virtual Numeric::uint64 get_time_stamp(const std::string& path);
 
            virtual bool set_executable_flag(const std::string& filename);
 
 
            virtual bool touch(const std::string& filename);
 
            virtual std::string normalized_path(const std::string& path);
 
 
            virtual std::string home_directory();
 
            virtual std::string documents_directory();
 
 
            virtual std::string load_file_as_string(const std::string& path);
            
            /************************ OS-independent **************************/
            
            virtual std::string extension(const std::string& path);
 
            virtual std::string base_name(
                const std::string& path, bool remove_extension = true
            );
 
            virtual std::string dir_name(const std::string& path);
 
            virtual void get_directory_entries(
                const std::string& path,
                std::vector<std::string>& result, bool recursive
            );
 
            virtual void get_files(
                const std::string& path,
                std::vector<std::string>& result, bool recursive = false
            );
 
            virtual void get_subdirectories(
                const std::string& path,
                std::vector<std::string>& result, bool recursive = false
            );
 
            virtual void flip_slashes(std::string& path);
 
            virtual bool copy_file(
                const std::string& from, const std::string& to
            );
        };
 
        class GEOGRAM_API MemoryNode : public Node {
        public:
 
            MemoryNode(const std::string& path="/") : path_(path) {
            }
            
            bool copy_file(
                const std::string& from, const std::string& to
            ) override ;
 
            std::string load_file_as_string(const std::string& path) override;
 
            virtual bool is_file(const std::string& path) override;
 
            virtual bool is_directory(const std::string& path) override;
 
            virtual bool create_directory(const std::string& path) override;
 
            virtual bool delete_directory(const std::string& path) override;
 
            virtual bool delete_file(const std::string& path) override;
 
            bool get_directory_entries(
                const std::string& path, std::vector<std::string>& result
            ) override;
 
 
            bool rename_file(
                const std::string& old_name, const std::string& new_name
            ) override;
 
            const char* get_file_contents(const std::string& path);
 
            bool create_file(const std::string& path, const char* content);
            
        protected:
            static void split_path(
                const std::string& path, std::string& leadingsubdir, 
                std::string& rest
            );
            
        private:
            std::string path_;
            std::map<std::string, SmartPointer<MemoryNode> > subnodes_;
            std::map<std::string, const char*> files_;
        };
        
        typedef SmartPointer<Node> Node_var;
 
        /**********************************************************/
 
        void GEOGRAM_API initialize();
 
        void GEOGRAM_API terminate();
        
        bool GEOGRAM_API is_file(const std::string& path);
 
        bool GEOGRAM_API is_directory(const std::string& path);
 
        bool GEOGRAM_API can_read_directory(const std::string& path);
 
        bool GEOGRAM_API can_write_directory(
            const std::string& path, bool create_missing_directories = false
        );
 
        bool GEOGRAM_API create_directory(const std::string& path);
 
        bool GEOGRAM_API delete_directory(const std::string& path);
 
        bool GEOGRAM_API delete_file(const std::string& path);
 
        bool GEOGRAM_API get_directory_entries(
            const std::string& path, std::vector<std::string>& result
        );
 
        std::string GEOGRAM_API get_current_working_directory();
        bool GEOGRAM_API set_current_working_directory(
            const std::string& path
        );
 
        bool GEOGRAM_API rename_file(
            const std::string& old_name, const std::string& new_name
        );
 
        Numeric::uint64 GEOGRAM_API get_time_stamp(
            const std::string& path
        );
 
        std::string GEOGRAM_API extension(const std::string& path);
 
        std::string GEOGRAM_API base_name(
            const std::string& path, bool remove_extension = true
        );
        
        std::string GEOGRAM_API dir_name(const std::string& path);
 
        void GEOGRAM_API get_directory_entries(
            const std::string& path,
            std::vector<std::string>& result, bool recursive
        );
 
        void GEOGRAM_API get_files(
            const std::string& path,
            std::vector<std::string>& result, bool recursive = false
        );
 
        void GEOGRAM_API get_subdirectories(
            const std::string& path,
            std::vector<std::string>& result, bool recursive = false
        );
 
        void GEOGRAM_API flip_slashes(std::string& path);
 
        bool GEOGRAM_API copy_file(
            const std::string& from, const std::string& to
        );
 
        bool GEOGRAM_API set_executable_flag(const std::string& filename);
 
        bool GEOGRAM_API touch(const std::string& filename);
 
        std::string GEOGRAM_API normalized_path(const std::string& path);
 
        std::string GEOGRAM_API absolute_path(const std::string& path);
 
        std::string GEOGRAM_API home_directory();
 
        std::string GEOGRAM_API documents_directory();
 
        void GEOGRAM_API get_root(Node*& root);
        
#ifdef GEO_OS_EMSCRIPTEN
        void set_file_system_changed_callback(void(*callback)());
#endif  
        
    }
}
 
#endif