CORE_IO.h

#ifndef CORE_IO_H
#define CORE_IO_H
 
 
//base classe header
#include "CORE_Object.h"
  
//include the iostream
#include <filesystem>
  
//include vector
#include <vector>
 
//strings functions header
#include "functions_string.h"
 
class CORE_IO : public CORE_Object {
    // ATTRIBUTES
 
    public:
  
    
private:
    // ASSOCIATIONS
  
  
    // METHODS
  
  
public:
    // CONSTRUCTORS
    CORE_IO() {
    }
   
  
  
  
    // DESTRUCTORS
    virtual ~CORE_IO(void) {
    }
  
  
public:
 
 
private:
  
   
public:
   
    virtual  tMemSize getMemorySize() const override {
        return sizeof(*this)+getContentsMemorySize();
    }
    
    inline static tBoolean IsFile(const tString& f) {
        return std::filesystem::is_regular_file(f);
    }
    inline static tBoolean IsPath(const tString& p) {
        return std::filesystem::is_directory(p);
    }
    inline static tBoolean Exists(const tString& f) {
        return std::filesystem::exists(f);
    }
    
    inline static tBoolean CreatePath(const tString& path) {
        std::filesystem::path p(path);
        return std::filesystem::create_directories(p);
    }
    inline static tBoolean Rename(const tString& file, const tString& newFile) {
        if (Exists(file)) {
            std::filesystem::rename(file,newFile);
            return true;
        }
        return false;
    }
    
    inline static tBoolean RemovePath(const tString& path,const tBoolean& force) {
        try {
            if (force) {
                return (std::filesystem::remove_all(path)!=0);
            } else {
                return std::filesystem::remove(path);
            }
        } catch(std::exception& e) {
            std::cerr<<e.what()<<"\n";
            return false;
        } 
    }
    inline static tBoolean RemovePath(const tString& path) {
        return RemovePath(path,false);
    }
 
    inline static tBoolean RemoveFile(const tString& file) {
        return  std::filesystem::remove(file);
    }
    
    inline static void  RemoveAllFiles(const tString& path) {
        std::vector<tString> files;
        //get all the files
        GetFiles(path,files);
        for_each(files.begin(),files.end(),[&](const auto& file) {
            std::filesystem::remove(file);
        });
    }
    inline static  void RemoveAllFiles(const tString& path,const tString& exts) {
        std::vector<tString> files;
        //get all the files
        GetFiles(path,exts,files);
        for_each(files.begin(),files.end(),[&](const auto& file) {
            std::filesystem::remove(file);
        });
    }
    
    inline static tString GetSystemPath(const tString& posix_path) {
        return std::filesystem::path(posix_path).make_preferred().string();
    }
    
    inline static void GetPaths(const tString& path,std::vector<tString>& paths) {
        paths.clear();
        if (std::filesystem::exists(path)) {
            for (const auto & entry : std::filesystem::directory_iterator(path))
                if  (std::filesystem::is_directory(entry.path())) paths.push_back(entry.path()); 
        }
    }
    inline static tString GetPathName(const tString& aPath) {
        std::filesystem::path p(aPath);
        return p.filename();
        
    }
    inline static void GetFiles(const tString& path,std::vector<tString>& files) {
        files.clear();
        if (std::filesystem::exists(path)) {
            for (const auto & entry : std::filesystem::directory_iterator(path))
                if  (std::filesystem::is_regular_file(entry.path())) files.push_back(entry.path()); 
        }
    }
    inline static void GetFiles(const tString& path,const tString& exts,std::vector<tString>& files) {
        files.clear();
        if (std::filesystem::exists(path)) {
            tString ext;
            for (const auto & entry : std::filesystem::directory_iterator(path)) {
                ext=GetExtension(entry.path());
                functions_string::toLower(ext);
                if  ( (ext.compare("")!=0) &&
                      (exts.find(ext)!=tString::npos)  &&
                      (std::filesystem::is_regular_file(entry.path()))) files.push_back(entry.path()); 
            }
        }
    }
    inline static void GetFiles(const tString& path,const tString& prefix,const tString& exts,std::vector<tString>& files) {
        files.clear();
        if (std::filesystem::exists(path)) {
            tString ext;
            for (const auto & entry : std::filesystem::directory_iterator(path)) {
                ext=GetExtension(entry.path());
                functions_string::toLower(ext);
                if  ( (ext.compare("")!=0) &&
                      (exts.find(ext)!=tString::npos)  &&
                      (std::filesystem::is_regular_file(entry.path())) &&
                      (entry.path().filename().string().find(prefix)==0)
                    ) files.push_back(entry.path().filename()); 
            }
        }
    }
    
    inline static tBoolean CopyFiles(const tString& sourcePath,const tString& exts,
                                     const tString& destPath,
                                     const tBoolean& overwrite) {
       
        if (std::filesystem::exists(sourcePath)&&std::filesystem::exists(destPath)) {
            tString ext;
            
            std::filesystem::copy_options copyOptions;
            if (overwrite)
                copyOptions=std::filesystem::copy_options::update_existing;//Replace the existing file only if it is older than the file being copied
            
            for (const auto & entry : std::filesystem::directory_iterator(sourcePath)) {
                ext=GetExtension(entry.path());
                functions_string::toLower(ext);
                if  ( (ext.compare("")!=0) && (exts.find(ext)!=tString::npos)  &&
                     (std::filesystem::is_regular_file(entry.path())))  std::filesystem::copy(entry.path(),destPath,copyOptions);
            }
            return true;
        }
        return false;
    }
    inline static tBoolean CopyFiles(const tString& sourcePath,
                                     const tString& destPath,
                                     const tBoolean& overwrite) {
        if (std::filesystem::exists(sourcePath)&&std::filesystem::exists(destPath)) {
            std::filesystem::copy_options copyOptions=std::filesystem::copy_options::skip_existing;
            if (overwrite) {
                //copyOptions=std::filesystem::copy_options::update_existing;//Replace the existing file only if it is older than the file being copied
                copyOptions=std::filesystem::copy_options::overwrite_existing;//Replace the existing file
            }
            std::filesystem::copy(sourcePath,destPath,copyOptions);
            return true;
        }
        return false;
    }
    inline static tBoolean CopyFile(const tString& source,
                                    const tString& dest,
                                    const tBoolean& overwrite) {
        if (std::filesystem::exists(dest)) {
            std::filesystem::copy_options copyOptions;
            if (overwrite)
                copyOptions=std::filesystem::copy_options::overwrite_existing;
            if (!std::filesystem::equivalent(source,dest)) std::filesystem::copy(source,dest,copyOptions);
            return true;
        }
        std::filesystem::copy(source,dest); 
        return true;
    }
    inline static tBoolean CopyFile(const tString& source,
                                    const tString& dest) {
        return CopyFile(source,dest,true);
    }
    
    inline static tBoolean CopyPath(const tString& sourcePath,const tString& destPath) {
        if (std::filesystem::exists(sourcePath)) {
            const auto copyOptions = std::filesystem::copy_options::update_existing //Replace the existing file only if it is older than the file being copied
                | std::filesystem::copy_options::recursive; //Recursively copy subdirectories and their content 
            
            std::filesystem::copy(sourcePath,destPath,copyOptions);
            return true;
        }
        return false;
    }
    
    inline static void GetContent(const tString& path,std::vector<tString>& content) {
        content.clear();
        for (const auto & entry : std::filesystem::directory_iterator(path))
            content.push_back(entry.path()); 
        
    }
 
    inline static tString GetCurrentPath()  {
        return std::filesystem::current_path() ;
    }
    inline static tString GetAbsolutePath(const tString& path)  {
        return std::filesystem::absolute(path) ;
    }
    inline static tString GetBaseName(const tString& file)  {
        return std::filesystem::path(file).stem();
    }
   
    inline static tString GetExtension(const tString& file)  {
        return std::filesystem::path(file).extension();
    }
    
    inline static tString GetPath(const tString& file) {
        return std::filesystem::path(file).parent_path();;
    }
    inline static tString GetFileName(const tString& file) {
        return std::filesystem::path(file).filename();
    }
   
 
    
};
 
#endif