1 /*

     2  * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 #ifndef FILEUTILS_H

    27 #define FILEUTILS_H

    28 

    29 

    30 #include <fstream>

    31 #include "SysInfo.h"

    32 

    33 

    34 namespace FileUtils {

    35 

    36     // Returns 'true' if the given character is a path separator.

    37     bool isDirSeparator(const tstring::value_type c);

    38 

    39     // checks if the file or directory exists

    40     bool isFileExists(const tstring &filePath);

    41 

    42     // checks is the specified file is a directory

    43     // returns false if the path does not exist

    44     bool isDirectory(const tstring &filePath);

    45 

    46     // checks if the specified directory is not empty

    47     // returns true if the path is an existing directory and

    48     // it contains at least one file other than "." or "..".

    49     bool isDirectoryNotEmpty(const tstring &dirPath);

    50 

    51     // returns directory part of the path.

    52     // returns empty string if the path contains only filename.

    53     // if the path ends with slash/backslash,

    54     // returns removeTrailingSlashes(path).

    55     tstring dirname(const tstring &path);

    56 

    57     // returns basename part of the path

    58     // if the path ends with slash/backslash, returns empty string.

    59     tstring basename(const tstring &path);

    60 

    61     /**

    62      * Translates forward slashes to back slashes and returns lower case version

    63      * of the given string.

    64      */

    65     tstring normalizePath(tstring v);

    66 

    67     // Returns suffix of the path. If the given path has a suffix the first

    68     // character of the return value is '.'.

    69     // Otherwise return value if empty string.

    70     tstring suffix(const tstring &path);

    71 

    72     // combines two strings into a path

    73     tstring combinePath(const tstring& parent, const tstring& child);

    74 

    75     // removes trailing slashes and backslashes in the path if any

    76     tstring removeTrailingSlash(const tstring& path);

    77 

    78     // Creates a file with unique name in the specified base directory,

    79     // throws an exception if operation fails

    80     // path is constructed as <prefix><random number><suffix>.

    81     // The function fails and throws exception if 'path' doesn't exist.

    82     tstring createTempFile(const tstring &prefix = _T(""),

    83             const tstring &suffix = _T(".tmp"),

    84             const tstring &path=SysInfo::getTempDir());

    85 

    86     // Creates a directory with unique name in the specified base directory,

    87     // throws an exception if operation fails

    88     // path is constructed as <prefix><random number><suffix>

    89     // The function fails and throws exception if 'path' doesn't exist.

    90     tstring createTempDirectory(const tstring &prefix = _T(""),

    91             const tstring &suffix = _T(".tmp"),

    92             const tstring &basedir=SysInfo::getTempDir());

    93 

    94     // If the file referenced with "prototype" parameter DOES NOT exist,

    95     // the return value is the given path. No new files created.

    96     // Otherwise the function creates another file in the same directory as

    97     // the given file with the same suffix and with the basename from the

    98     // basename of the given file with some random chars appended to ensure

    99     // created file is unique.

   100     tstring createUniqueFile(const tstring &prototype);

   101 

   102     // Creates directory and subdirectories if don't exist.

   103     // Currently supports only "standard" path like "c:\bla-bla"

   104     // If 'createdDirs' parameter is not NULL, the given array is appended with

   105     // all subdirectories created by this function call.

   106     void createDirectory(const tstring &path, tstring_array* createdDirs=0);

   107 

   108     // copies file from fromPath to toPath.

   109     // Creates output directory if doesn't exist.

   110     void copyFile(const tstring& fromPath, const tstring& toPath,

   111             bool failIfExists);

   112 

   113     // moves file from fromPath to toPath.

   114     // Creates output directory if doesn't exist.

   115     void moveFile(const tstring& fromPath, const tstring& toPath,

   116             bool failIfExists);

   117 

   118     // Throws exception if fails to delete specified 'path'.

   119     // Exits normally if 'path' doesn't exist or it has been deleted.

   120     // Attempts to strip R/O attribute if delete fails and retry delete.

   121     void deleteFile(const tstring &path);

   122     // Returns 'false' if fails to delete specified 'path'.

   123     // Returns 'true' if 'path' doesn't exist or it has been deleted.

   124     // Attempts to strip R/O attribute if delete fails and retry delete.

   125     bool deleteFile(const tstring &path, const std::nothrow_t &) throw();

   126 

   127     // Like deleteFile(), but applies to directories.

   128     void deleteDirectory(const tstring &path);

   129     bool deleteDirectory(const tstring &path, const std::nothrow_t &) throw();

   130 

   131     // Deletes all files (not subdirectories) from the specified directory.

   132     // Exits normally if all files in 'dirPath' have been deleted or if

   133     // 'dirPath' doesn't exist.

   134     // Throws exception if 'dirPath' references existing file system object

   135     // which is not a directory or when the first failure of file delete

   136     // occurs.

   137     void deleteFilesInDirectory(const tstring &dirPath);

   138     // Deletes all files (not subdirectories) from the specified directory.

   139     // Returns 'true' normally if all files in 'dirPath' have been deleted or

   140     // if 'dirPath' doesn't exist.

   141     // Returns 'false' if 'dirPath' references existing file system object

   142     // which is not a directory or if failed to delete one ore more files in

   143     // 'dirPath' directory.

   144     // Doesn't abort iteration over files if the given directory after the

   145     // first failure to delete a file.

   146     bool deleteFilesInDirectory(const tstring &dirPath,

   147             const std::nothrow_t &) throw();

   148     // Like deleteFilesInDirectory, but deletes subdirectories as well

   149     void deleteDirectoryRecursive(const tstring &dirPath);

   150     bool deleteDirectoryRecursive(const tstring &dirPath,

   151             const std::nothrow_t &) throw();

   152 

   153     class DirectoryCallback {

   154     public:

   155         virtual ~DirectoryCallback() {};

   156 

   157         virtual bool onFile(const tstring& path) {

   158             return true;

   159         }

   160         virtual bool onDirectory(const tstring& path) {

   161             return true;

   162         }

   163     };

   164 

   165     // Calls the given callback for every file and subdirectory of

   166     // the given directory.

   167     void iterateDirectory(const tstring &dirPath, DirectoryCallback& callback);

   168 

   169     /**

   170      * Replace file suffix, example replaceSuffix("file/path.txt", ".csv")

   171      * @param path file path to replace suffix

   172      * @param suffix new suffix for path

   173      * @return return file path with new suffix

   174      */

   175     tstring replaceSuffix(const tstring& path, const tstring& suffix=tstring());

   176 

   177     class DirectoryIterator: DirectoryCallback {

   178     public:

   179         DirectoryIterator(const tstring& root=tstring()): root(root) {

   180             recurse().withFiles().withFolders();

   181         }

   182 

   183         DirectoryIterator& recurse(bool v=true) {

   184             theRecurse = v;

   185             return *this;

   186         }

   187 

   188         DirectoryIterator& withFiles(bool v=true) {

   189             theWithFiles = v;

   190             return *this;

   191         }

   192 

   193         DirectoryIterator& withFolders(bool v=true) {

   194             theWithFolders = v;

   195             return *this;

   196         }

   197 

   198         tstring_array findItems() {

   199             tstring_array reply;

   200             findItems(reply);

   201             return reply;

   202         }

   203 

   204         DirectoryIterator& findItems(tstring_array& v);

   205 

   206     private:

   207         virtual bool onFile(const tstring& path);

   208         virtual bool onDirectory(const tstring& path);

   209 

   210     private:

   211         bool theRecurse;

   212         bool theWithFiles;

   213         bool theWithFolders;

   214         tstring root;

   215         tstring_array items;

   216     };

   217 

   218     // Returns array of all the files/sub-folders from the given directory,

   219     // empty array if basedir is not a directory. The returned

   220     // array is ordered from top down (i.e. dirs are listed first followed

   221     // by subfolders and files).

   222     // Order of subfolders and files is undefined

   223     // but usually they are sorted by names.

   224     inline tstring_array listAllContents(const tstring& basedir) {

   225         return DirectoryIterator(basedir).findItems();

   226     }

   227 

   228     // Helper to construct path from multiple components.

   229     //

   230     // Sample usage:

   231     //  Construct "c:\Program Files\Java" string from three components

   232     //

   233     //  tstring path = FileUtils::mkpath()  << _T("c:")

   234     //                                      << _T("Program Files")

   235     //                                      << _T("Java");

   236     //

   237     class mkpath {

   238     public:

   239         operator const tstring& () const {

   240             return path;

   241         }

   242 

   243         mkpath& operator << (const tstring& p) {

   244             path = combinePath(path, p);

   245             return *this;

   246         }

   247 

   248         // mimic std::string

   249         const tstring::value_type* c_str() const {

   250             return path.c_str();

   251         }

   252     private:

   253         tstring path;

   254     };

   255 

   256     struct Directory {

   257         Directory() {

   258         }

   259 

   260         Directory(const tstring &parent,

   261                 const tstring &subdir) : parent(parent), subdir(subdir)  {

   262         }

   263 

   264         operator tstring () const {

   265             return getPath();

   266         }

   267 

   268         tstring getPath() const {

   269             return combinePath(parent, subdir);

   270         }

   271 

   272         bool empty() const {

   273             return (parent.empty() && subdir.empty());

   274         }

   275 

   276         tstring parent;

   277         tstring subdir;

   278     };

   279 

   280     // Deletes list of files and directories in batch mode.

   281     // Registered files and directories are deleted when destructor is called.

   282     // Order or delete operations is following:

   283     //  - delete items registered with appendFile() calls;

   284     //  - delete items registered with appendAllFilesInDirectory() calls;

   285     //  - delete items registered with appendRecursiveDirectory() calls;

   286     //  - delete items registered with appendEmptyDirectory() calls.

   287     class Deleter {

   288     public:

   289         Deleter() {

   290         }

   291 

   292         ~Deleter() {

   293             execute();

   294         }

   295 

   296         typedef std::pair<tstring, int> Path;

   297         typedef std::vector<Path> Paths;

   298 

   299         /**

   300          * Appends all records from the given deleter Deleter into this Deleter

   301          * instance. On success array with records in the passed in Deleter

   302          * instance is emptied.

   303          */

   304         Deleter& appendFrom(Deleter& other) {

   305             Paths tmp(paths);

   306             tmp.insert(tmp.end(), other.paths.begin(), other.paths.end());

   307             Paths empty;

   308             other.paths.swap(empty);

   309             paths.swap(tmp);

   310             return *this;

   311         }

   312 

   313         // Schedule file for deletion.

   314         Deleter& appendFile(const tstring& path);

   315 

   316         // Schedule files for deletion.

   317         template <class It>

   318         Deleter& appendFiles(It b, It e) {

   319             for (It it = b; it != e; ++it) {

   320                 appendFile(*it);

   321             }

   322             return *this;

   323         }

   324 

   325         // Schedule files for deletion in the given directory.

   326         template <class It>

   327         Deleter& appendFiles(const tstring& dirname, It b, It e) {

   328             for (It it = b; it != e; ++it) {

   329                 appendFile(FileUtils::mkpath() << dirname << *it);

   330             }

   331             return *this;

   332         }

   333 

   334         // Schedule empty directory for deletion with empty roots

   335         // (up to Directory.parent).

   336         Deleter& appendEmptyDirectory(const Directory& dir);

   337 

   338         // Schedule empty directory for deletion without roots.

   339         // This is a particular case of

   340         // appendEmptyDirectory(const Directory& dir)

   341         // with Directory(dirname(path), basename(path)).

   342         Deleter& appendEmptyDirectory(const tstring& path);

   343 

   344         // Schedule all file from the given directory for deletion.

   345         Deleter& appendAllFilesInDirectory(const tstring& path);

   346 

   347         // Schedule directory for recursive deletion.

   348         Deleter& appendRecursiveDirectory(const tstring& path);

   349 

   350         void cancel() {

   351             paths.clear();

   352         }

   353 

   354         // Deletes scheduled files and directories. After this function

   355         // is called internal list of scheduled items is emptied.

   356         void execute();

   357 

   358     private:

   359         Paths paths;

   360     };

   361 

   362 

   363     /**

   364      * Helper to write chunks of data into binary file.

   365      * Creates temporary file in the same folder with destination file.

   366      * All subsequent requests to save data chunks are redirected to temporary

   367      * file. finalize() method closes temporary file stream and renames

   368      * temporary file.

   369      * If finalize() method is not called, temporary file is deleted in

   370      * ~FileWriter(), destination file is not touched.

   371      */

   372     class FileWriter {

   373     public:

   374         explicit FileWriter(const tstring& path);

   375 

   376         FileWriter& write(const void* buf, size_t bytes);

   377 

   378         template <class Ctnr>

   379         FileWriter& write(const Ctnr& buf) {

   380             return write(buf.data(),

   381                             buf.size() * sizeof(typename Ctnr::value_type));

   382         }

   383 

   384         void finalize();

   385 

   386     private:

   387         // Not accessible by design!

   388         FileWriter& write(const std::wstring& str);

   389 

   390     private:

   391         tstring tmpFile;

   392         Deleter cleaner;

   393         std::ofstream tmp;

   394         tstring dstPath;

   395     };

   396 } // FileUtils

   397 

   398 #endif // FILEUTILS_H