Filesystem.h

Go to the documentation of this file.

 
#pragma once
 
#include <string>
#include <stdexcept>
#include <vector>
 
namespace Gorgon {
 
    namespace Filesystem {
        
        class PathNotFoundError : public std::runtime_error {
        public:
            PathNotFoundError() : std::runtime_error("File not found") { }
            
            PathNotFoundError(const std::string &what) : std::runtime_error(what) { }
        };
 
        class EntryPoint {
        public:
 
            EntryPoint() { }
 
            std::string Path;
 
            bool Readable = false;
 
            bool Writable = false;
            
            bool Removable = false;
 
            std::string Name;
        };
 
 
        void Initialize();
 
    
        bool CreateDirectory(const std::string &path);
        
        bool IsDirectory(const std::string &path);
 
        bool IsFile(const std::string &path);
        
        bool IsExists(const std::string &path);
 
        bool IsWritable(const std::string &path);
 
        bool IsHidden(const std::string &path);
 
        std::string Canonical(const std::string &path);
        
        std::string Relative(std::string path, std::string base=".");
 
        bool Delete(const std::string &path);
        
        bool ChangeDirectory(const std::string &path);
        
        std::string CurrentDirectory();
        
        inline std::string Join(std::string path1, const std::string &path2) {
            if(path1.empty() || path1.back()!='/') {
                path1.push_back('/');
            }
            path1+=path2;
            
            return path1;
        }
 
        inline std::string GetDirectory(std::string filepath) {
            auto pos=filepath.find_last_of('/');
 
            if(pos!=filepath.npos) {
                filepath=filepath.substr(0,pos);
            }
            else {
                filepath=CurrentDirectory();
            }
 
            return filepath;
        }
 
        inline std::string GetFilename(std::string path) {
            auto pos=path.find_last_of('/');
 
            if(pos!=path.npos) {
                path=path.substr(pos+1);
            }
 
            return path;
        }
        
        std::string GetExtension(std::string path);
        
        inline std::string GetBasename(std::string path) {
            path = GetFilename(path);
            
            auto pos = path.find_last_of('.');
            
            if(pos == path.npos) return path;
            
            path = path.substr(0, pos);
            
            return path;
        }
 
        bool Copy(const std::string &source, const std::string &target);
 
        template<template<class> class C_>
        bool Copy(const C_<std::string> &source, const std::string &target) {
            for(const auto &s : source) {
                if(!Copy(s, target+"/"+GetFilename(s))) return false;
            }
 
            return true;
        }
 
        template<template<class, class> class C_, class A_>
        bool Copy(const C_<std::string, A_> &source, const std::string &target) {
            for(const auto &s : source) {
                if(!Copy(s, target+"/"+GetFilename(s))) return false;
            }
 
            return true;
        }
 
        template<class I_>
        bool Copy(const I_ &begin, const I_ &end, const std::string &target) {
            for(I_ it=begin;it!=end;++it) {
                if(!Copy(*it, target+"/"+GetFilename(*it))) return false;
            }
 
            return true;
        }
 
        template<template<class> class C_>
        bool Copy(const std::string &sourcedir, const C_<std::string> &source, const std::string &target) {
            for(const auto &s : source) {
                if(!Copy(sourcedir+"/"+s, target+"/"+s)) return false;
            }
 
            return true;
        }
 
        template<class I_>
        bool Copy(const std::string &sourcedir, const I_ &begin, const I_ &end, const std::string &target) {
            for(I_ it=begin;it!=end;++it) {
                if(!Copy(sourcedir+"/"+*it, target+"/"+*it)) return false;
            }
 
            return true;
        }
        
        bool Move(const std::string &source, const std::string &target);
    
        unsigned long long Size(const std::string &filename);
        
        bool Save(const std::string &filename, const std::string &data, bool append=false);
        
        std::string Load(const std::string &filename);
        
        std::string StartupDirectory();
        
        std::string ExePath();
        
        std::string ExeDirectory();
        
        std::vector<EntryPoint> EntryPoints();
 
        std::string LocateResource(const std::string &path, const std::string &directory="", bool localonly=true);
 
    }
 
}