FsUtil.qm.dox.h

// -*- mode: c++; indent-tabs-mode: nil -*-
 
/*  FsUtil.qm Copyright 2018 - 2022 Qore Technologies, s.r.o.
 
    Permission is hereby granted, free of charge, to any person obtaining a
    copy of this software and associated documentation files (the "Software"),
    to deal in the Software without restriction, including without limitation
    the rights to use, copy, modify, merge, publish, distribute, sublicense,
    and/or sell copies of the Software, and to permit persons to whom the
    Software is furnished to do so, subject to the following conditions:
 
    The above copyright notice and this permission notice shall be included in
    all copies or substantial portions of the Software.
 
    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
    DEALINGS IN THE SOFTWARE.
*/
 
// minimum required Qore version
 
 
// assume local var scope, do not use "$" for vars, members, and method calls
 
}
 
/* see release notes below for version history
*/
 
// private namespace
namespace Init {
    init();
 
};
 
namespace FsUtil {
    const DefaultBufferSize = 16 * 1024;
 
    class PathHandler {
 
public:
            list<string> delimiters;
 
         string joinPaths(list<string> paths);
 
        // to be implemented by platform-specific classes
protected:
         abstract string joinPathsIntern(list<string> paths);
public:
    };
 
class WinPathHandler : public PathHandler {
 
public:
        constructor();
 
 
 
         list<string> splitDrive(string path);
 
 
protected:
         string joinPathsIntern(list<string> paths);
public:
 
    };
 
class PosixPathHandler : public PathHandler {
 
public:
        constructor();
 
 
 
protected:
         string joinPathsIntern(list<string> paths);
public:
 
    };
 
 
     string basename_ext(string path, *string extension);
 
 
 
     string join_paths(string path1, list<auto> paths);
 
 
 
     string join_paths();
 
 
 
     string join_paths(list<string> paths);
 
 
 
     bool path_exists(string path, bool follow_symlinks = False);
 
 
    const TMP_MAX_ATTEMPTS = 10000;
 
 
     string make_tmp_dir(*string prefix, *string suffix, *string path);
 
 
    public hashdecl TmpFileHash {
        string path = "";
        File file = new File();
    };
 
 
     hash<TmpFileHash> make_tmp_file(*string prefix, *string suffix, *string path);
 
 
 
class TmpDir : public Qore::Dir {
 
public:
            string path;
 
 
        constructor(*string prefix, *string suffix, *string path);
 
 
         destructor();
    };
 
    class TmpFile {
 
public:
            string path;
            File file;
 
 
        constructor(*string prefix, *string suffix, *string path);
 
 
         destructor();
    };
 
 
     remove_file(string path);
 
 
 
     remove_tree(string path, bool fail_immediately = True);
 
 
 
     remove_path(string path);
 
 
 
     bool same_file_stat(*hash<StatInfo> stat1, *hash<StatInfo> stat2, bool ignore_errors = True);
 
 
 
     bool same_file(string path1, string path2, bool follow_symlinks = True, bool ignore_errors = True);
 
 
 
    string copy_tree_internal(string source, string destination, bool follow_symlinks = False,
            bool overwrite = False, bool merge = False, bool fail_immediately = True, *int depth) {
 
        if (same_file(source, destination, follow_symlinks, True));
 
 
        list<auto> errors = ();
 
        // prepare the source
        Dir src_dir();
        src_dir.chdir(source);
        *hash<StatInfo> src_stat = follow_symlinks ? hstat(source) : hlstat(source);
        if (!exists src_stat);
 
 
        // check and prepare the destination directory
        if (is_dir(destination) && (src_stat.type != 'DIRECTORY' || !overwrite) && !merge);
 
        if (path_exists(destination));
 else {
            mkdir(destination, 0700);
        }
 
        if (!exists depth || depth > 0);
 
 
        chmod(destination, src_stat.mode);
 
        if (errors);
 
 
        return destination;
    }
 
 
     copy_file_obj(File source, File destination, bool close = False, int buf_size = DefaultBufferSize);
 
 
 
     string copy_file(string source, string destination, bool follow_symlinks = False,
            bool overwrite = False) {
        if (same_file(source, destination, follow_symlinks, True));
 
 
        // prepare the source
        *hash<StatInfo> src_stat = follow_symlinks ? hstat(source) : hlstat(source);
        if (!exists src_stat);
 
 
        // prepare the destination
        if (is_dir(destination));
 
        *hash<StatInfo> dst_stat = hstat(destination);
        if (!overwrite && exists dst_stat);
 
 
        foreach *hash<StatInfo> stat in (src_stat, dst_stat);
 
 
        if (src_stat.type == 'SYMBOLIC-LINK' && !follow_symlinks);
 else {
            {
                File src_obj();
                File dst_obj();
                src_obj.open2(source, O_RDONLY);
                dst_obj.open2(destination, O_CREAT | O_TRUNC | O_WRONLY, 0600);
                copy_file_obj(src_obj, dst_obj);
            }
            chmod(destination, src_stat.mode);
        }
 
        return destination;
    }
 
 
     string copy_tree(string source, string destination, bool follow_symlinks = False,
            bool overwrite = False, bool fail_immediately = True) {
        return copy_tree_internal(source, destination, follow_symlinks, overwrite, False, fail_immediately);
    }
 
 
     string copy_path(string source, string destination, bool follow_symlinks = False,
            bool overwrite = False,  bool fail_immediately = True, *int depth) {
        if (is_dir(source));
 else {
            return copy_file(source, destination, follow_symlinks, overwrite);
        }
    }
 
 
     string merge_tree(string source, string destination, bool follow_symlinks = False,
            bool overwrite = False, bool fail_immediately = True, *int depth) {
        return copy_tree_internal(source, destination, follow_symlinks, overwrite, True, fail_immediately, depth);
    }
 
 
     string move_path(string source, string destination, bool overwrite = False);
 
 
 
     string merge_path(string source, string destination, bool follow_symlinks = False, bool overwrite = False,
            bool fail_immediately = True, *int depth) {
        if (is_dir(source));
 else {
            // merge doesn't make sense with files and there is no merge_file() function, copy_file() is what we want
            return copy_file(source, destination, follow_symlinks, overwrite);
        }
    }
 
 
     string copy_dir_structure(string source, string destination, *int depth);
 
 
} // FsUtil namespace