- added JUCE library code
git-svn-id: http://moon:8086/svn/software/trunk/projects/FsTrack@357 b431acfa-c32f-4a4a-93f1-934dc6c82436
This commit is contained in:
@@ -0,0 +1,166 @@
|
||||
/*
|
||||
==============================================================================
|
||||
|
||||
This file is part of the juce_core module of the JUCE library.
|
||||
Copyright (c) 2013 - Raw Material Software Ltd.
|
||||
|
||||
Permission to use, copy, modify, and/or distribute this software for any purpose with
|
||||
or without fee is hereby granted, provided that the above copyright notice and this
|
||||
permission notice appear in all copies.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
|
||||
TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN
|
||||
NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
|
||||
DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
|
||||
IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
|
||||
CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
|
||||
NOTE! This permissive ISC license applies ONLY to files within the juce_core module!
|
||||
All other JUCE modules are covered by a dual GPL/commercial license, so if you are
|
||||
using any other modules, be sure to check that you also comply with their license.
|
||||
|
||||
For more details, visit www.juce.com
|
||||
|
||||
==============================================================================
|
||||
*/
|
||||
|
||||
DirectoryIterator::DirectoryIterator (const File& directory, bool recursive,
|
||||
const String& pattern, const int type)
|
||||
: wildCards (parseWildcards (pattern)),
|
||||
fileFinder (directory, (recursive || wildCards.size() > 1) ? "*" : pattern),
|
||||
wildCard (pattern),
|
||||
path (File::addTrailingSeparator (directory.getFullPathName())),
|
||||
index (-1),
|
||||
totalNumFiles (-1),
|
||||
whatToLookFor (type),
|
||||
isRecursive (recursive),
|
||||
hasBeenAdvanced (false)
|
||||
{
|
||||
// you have to specify the type of files you're looking for!
|
||||
jassert ((type & (File::findFiles | File::findDirectories)) != 0);
|
||||
jassert (type > 0 && type <= 7);
|
||||
}
|
||||
|
||||
DirectoryIterator::~DirectoryIterator()
|
||||
{
|
||||
}
|
||||
|
||||
StringArray DirectoryIterator::parseWildcards (const String& pattern)
|
||||
{
|
||||
StringArray s;
|
||||
s.addTokens (pattern, ";,", "\"'");
|
||||
s.trim();
|
||||
s.removeEmptyStrings();
|
||||
return s;
|
||||
}
|
||||
|
||||
bool DirectoryIterator::fileMatches (const StringArray& wildCards, const String& filename)
|
||||
{
|
||||
for (int i = 0; i < wildCards.size(); ++i)
|
||||
if (filename.matchesWildcard (wildCards[i], ! File::areFileNamesCaseSensitive()))
|
||||
return true;
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
bool DirectoryIterator::next()
|
||||
{
|
||||
return next (nullptr, nullptr, nullptr, nullptr, nullptr, nullptr);
|
||||
}
|
||||
|
||||
bool DirectoryIterator::next (bool* const isDirResult, bool* const isHiddenResult, int64* const fileSize,
|
||||
Time* const modTime, Time* const creationTime, bool* const isReadOnly)
|
||||
{
|
||||
for (;;)
|
||||
{
|
||||
hasBeenAdvanced = true;
|
||||
|
||||
if (subIterator != nullptr)
|
||||
{
|
||||
if (subIterator->next (isDirResult, isHiddenResult, fileSize, modTime, creationTime, isReadOnly))
|
||||
return true;
|
||||
|
||||
subIterator = nullptr;
|
||||
}
|
||||
|
||||
String filename;
|
||||
bool isDirectory, isHidden = false, shouldContinue = false;
|
||||
|
||||
while (fileFinder.next (filename, &isDirectory,
|
||||
(isHiddenResult != nullptr || (whatToLookFor & File::ignoreHiddenFiles) != 0) ? &isHidden : nullptr,
|
||||
fileSize, modTime, creationTime, isReadOnly))
|
||||
{
|
||||
++index;
|
||||
|
||||
if (! filename.containsOnly ("."))
|
||||
{
|
||||
bool matches = false;
|
||||
|
||||
if (isDirectory)
|
||||
{
|
||||
if (isRecursive && ((whatToLookFor & File::ignoreHiddenFiles) == 0 || ! isHidden))
|
||||
subIterator = new DirectoryIterator (File::createFileWithoutCheckingPath (path + filename),
|
||||
true, wildCard, whatToLookFor);
|
||||
|
||||
matches = (whatToLookFor & File::findDirectories) != 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
matches = (whatToLookFor & File::findFiles) != 0;
|
||||
}
|
||||
|
||||
// if we're not relying on the OS iterator to do the wildcard match, do it now..
|
||||
if (matches && (isRecursive || wildCards.size() > 1))
|
||||
matches = fileMatches (wildCards, filename);
|
||||
|
||||
if (matches && (whatToLookFor & File::ignoreHiddenFiles) != 0)
|
||||
matches = ! isHidden;
|
||||
|
||||
if (matches)
|
||||
{
|
||||
currentFile = File::createFileWithoutCheckingPath (path + filename);
|
||||
if (isHiddenResult != nullptr) *isHiddenResult = isHidden;
|
||||
if (isDirResult != nullptr) *isDirResult = isDirectory;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
if (subIterator != nullptr)
|
||||
{
|
||||
shouldContinue = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (! shouldContinue)
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
const File& DirectoryIterator::getFile() const
|
||||
{
|
||||
if (subIterator != nullptr && subIterator->hasBeenAdvanced)
|
||||
return subIterator->getFile();
|
||||
|
||||
// You need to call DirectoryIterator::next() before asking it for the file that it found!
|
||||
jassert (hasBeenAdvanced);
|
||||
|
||||
return currentFile;
|
||||
}
|
||||
|
||||
float DirectoryIterator::getEstimatedProgress() const
|
||||
{
|
||||
if (totalNumFiles < 0)
|
||||
totalNumFiles = File (path).getNumberOfChildFiles (File::findFilesAndDirectories);
|
||||
|
||||
if (totalNumFiles <= 0)
|
||||
return 0.0f;
|
||||
|
||||
const float detailedIndex = (subIterator != nullptr) ? index + subIterator->getEstimatedProgress()
|
||||
: (float) index;
|
||||
|
||||
return detailedIndex / totalNumFiles;
|
||||
}
|
||||
@@ -0,0 +1,159 @@
|
||||
/*
|
||||
==============================================================================
|
||||
|
||||
This file is part of the juce_core module of the JUCE library.
|
||||
Copyright (c) 2013 - Raw Material Software Ltd.
|
||||
|
||||
Permission to use, copy, modify, and/or distribute this software for any purpose with
|
||||
or without fee is hereby granted, provided that the above copyright notice and this
|
||||
permission notice appear in all copies.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
|
||||
TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN
|
||||
NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
|
||||
DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
|
||||
IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
|
||||
CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
|
||||
NOTE! This permissive ISC license applies ONLY to files within the juce_core module!
|
||||
All other JUCE modules are covered by a dual GPL/commercial license, so if you are
|
||||
using any other modules, be sure to check that you also comply with their license.
|
||||
|
||||
For more details, visit www.juce.com
|
||||
|
||||
==============================================================================
|
||||
*/
|
||||
|
||||
#ifndef JUCE_DIRECTORYITERATOR_H_INCLUDED
|
||||
#define JUCE_DIRECTORYITERATOR_H_INCLUDED
|
||||
|
||||
|
||||
//==============================================================================
|
||||
/**
|
||||
Searches through the files in a directory, returning each file that is found.
|
||||
|
||||
A DirectoryIterator will search through a directory and its subdirectories using
|
||||
a wildcard filepattern match.
|
||||
|
||||
If you may be scanning a large number of files, it's usually smarter to use this
|
||||
class than File::findChildFiles() because it allows you to stop at any time, rather
|
||||
than having to wait for the entire scan to finish before getting the results.
|
||||
|
||||
It also provides an estimate of its progress, using a (highly inaccurate!) algorithm.
|
||||
*/
|
||||
class JUCE_API DirectoryIterator
|
||||
{
|
||||
public:
|
||||
//==============================================================================
|
||||
/** Creates a DirectoryIterator for a given directory.
|
||||
|
||||
After creating one of these, call its next() method to get the
|
||||
first file - e.g. @code
|
||||
|
||||
DirectoryIterator iter (File ("/animals/mooses"), true, "*.moose");
|
||||
|
||||
while (iter.next())
|
||||
{
|
||||
File theFileItFound (iter.getFile());
|
||||
|
||||
... etc
|
||||
}
|
||||
@endcode
|
||||
|
||||
@param directory the directory to search in
|
||||
@param isRecursive whether all the subdirectories should also be searched
|
||||
@param wildCard the file pattern to match. This may contain multiple patterns
|
||||
separated by a semi-colon or comma, e.g. "*.jpg;*.png"
|
||||
@param whatToLookFor a value from the File::TypesOfFileToFind enum, specifying
|
||||
whether to look for files, directories, or both.
|
||||
*/
|
||||
DirectoryIterator (const File& directory,
|
||||
bool isRecursive,
|
||||
const String& wildCard = "*",
|
||||
int whatToLookFor = File::findFiles);
|
||||
|
||||
/** Destructor. */
|
||||
~DirectoryIterator();
|
||||
|
||||
/** Moves the iterator along to the next file.
|
||||
|
||||
@returns true if a file was found (you can then use getFile() to see what it was) - or
|
||||
false if there are no more matching files.
|
||||
*/
|
||||
bool next();
|
||||
|
||||
/** Moves the iterator along to the next file, and returns various properties of that file.
|
||||
|
||||
If you need to find out details about the file, it's more efficient to call this method than
|
||||
to call the normal next() method and then find out the details afterwards.
|
||||
|
||||
All the parameters are optional, so pass null pointers for any items that you're not
|
||||
interested in.
|
||||
|
||||
@returns true if a file was found (you can then use getFile() to see what it was) - or
|
||||
false if there are no more matching files. If it returns false, then none of the
|
||||
parameters will be filled-in.
|
||||
*/
|
||||
bool next (bool* isDirectory,
|
||||
bool* isHidden,
|
||||
int64* fileSize,
|
||||
Time* modTime,
|
||||
Time* creationTime,
|
||||
bool* isReadOnly);
|
||||
|
||||
/** Returns the file that the iterator is currently pointing at.
|
||||
|
||||
The result of this call is only valid after a call to next() has returned true.
|
||||
*/
|
||||
const File& getFile() const;
|
||||
|
||||
/** Returns a guess of how far through the search the iterator has got.
|
||||
|
||||
@returns a value 0.0 to 1.0 to show the progress, although this won't be
|
||||
very accurate.
|
||||
*/
|
||||
float getEstimatedProgress() const;
|
||||
|
||||
private:
|
||||
//==============================================================================
|
||||
class NativeIterator
|
||||
{
|
||||
public:
|
||||
NativeIterator (const File& directory, const String& wildCard);
|
||||
~NativeIterator();
|
||||
|
||||
bool next (String& filenameFound,
|
||||
bool* isDirectory, bool* isHidden, int64* fileSize,
|
||||
Time* modTime, Time* creationTime, bool* isReadOnly);
|
||||
|
||||
class Pimpl;
|
||||
|
||||
private:
|
||||
friend class DirectoryIterator;
|
||||
friend struct ContainerDeletePolicy<Pimpl>;
|
||||
ScopedPointer<Pimpl> pimpl;
|
||||
|
||||
JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (NativeIterator)
|
||||
};
|
||||
|
||||
friend struct ContainerDeletePolicy<NativeIterator::Pimpl>;
|
||||
StringArray wildCards;
|
||||
NativeIterator fileFinder;
|
||||
String wildCard, path;
|
||||
int index;
|
||||
mutable int totalNumFiles;
|
||||
const int whatToLookFor;
|
||||
const bool isRecursive;
|
||||
bool hasBeenAdvanced;
|
||||
ScopedPointer<DirectoryIterator> subIterator;
|
||||
File currentFile;
|
||||
|
||||
static StringArray parseWildcards (const String& pattern);
|
||||
static bool fileMatches (const StringArray& wildCards, const String& filename);
|
||||
|
||||
JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (DirectoryIterator)
|
||||
};
|
||||
|
||||
#endif // JUCE_DIRECTORYITERATOR_H_INCLUDED
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,981 @@
|
||||
/*
|
||||
==============================================================================
|
||||
|
||||
This file is part of the juce_core module of the JUCE library.
|
||||
Copyright (c) 2013 - Raw Material Software Ltd.
|
||||
|
||||
Permission to use, copy, modify, and/or distribute this software for any purpose with
|
||||
or without fee is hereby granted, provided that the above copyright notice and this
|
||||
permission notice appear in all copies.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
|
||||
TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN
|
||||
NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
|
||||
DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
|
||||
IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
|
||||
CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
|
||||
NOTE! This permissive ISC license applies ONLY to files within the juce_core module!
|
||||
All other JUCE modules are covered by a dual GPL/commercial license, so if you are
|
||||
using any other modules, be sure to check that you also comply with their license.
|
||||
|
||||
For more details, visit www.juce.com
|
||||
|
||||
==============================================================================
|
||||
*/
|
||||
|
||||
#ifndef JUCE_FILE_H_INCLUDED
|
||||
#define JUCE_FILE_H_INCLUDED
|
||||
|
||||
|
||||
//==============================================================================
|
||||
/**
|
||||
Represents a local file or directory.
|
||||
|
||||
This class encapsulates the absolute pathname of a file or directory, and
|
||||
has methods for finding out about the file and changing its properties.
|
||||
|
||||
To read or write to the file, there are methods for returning an input or
|
||||
output stream.
|
||||
|
||||
@see FileInputStream, FileOutputStream
|
||||
*/
|
||||
class JUCE_API File
|
||||
{
|
||||
public:
|
||||
//==============================================================================
|
||||
/** Creates an (invalid) file object.
|
||||
|
||||
The file is initially set to an empty path, so getFullPath() will return
|
||||
an empty string, and comparing the file to File::nonexistent will return
|
||||
true.
|
||||
|
||||
You can use its operator= method to point it at a proper file.
|
||||
*/
|
||||
File() noexcept {}
|
||||
|
||||
/** Creates a file from an absolute path.
|
||||
|
||||
If the path supplied is a relative path, it is taken to be relative
|
||||
to the current working directory (see File::getCurrentWorkingDirectory()),
|
||||
but this isn't a recommended way of creating a file, because you
|
||||
never know what the CWD is going to be.
|
||||
|
||||
On the Mac/Linux, the path can include "~" notation for referring to
|
||||
user home directories.
|
||||
*/
|
||||
File (const String& absolutePath);
|
||||
|
||||
/** Creates a copy of another file object. */
|
||||
File (const File&);
|
||||
|
||||
/** Destructor. */
|
||||
~File() noexcept {}
|
||||
|
||||
/** Sets the file based on an absolute pathname.
|
||||
|
||||
If the path supplied is a relative path, it is taken to be relative
|
||||
to the current working directory (see File::getCurrentWorkingDirectory()),
|
||||
but this isn't a recommended way of creating a file, because you
|
||||
never know what the CWD is going to be.
|
||||
|
||||
On the Mac/Linux, the path can include "~" notation for referring to
|
||||
user home directories.
|
||||
*/
|
||||
File& operator= (const String& newAbsolutePath);
|
||||
|
||||
/** Copies from another file object. */
|
||||
File& operator= (const File& otherFile);
|
||||
|
||||
#if JUCE_COMPILER_SUPPORTS_MOVE_SEMANTICS
|
||||
File (File&&) noexcept;
|
||||
File& operator= (File&&) noexcept;
|
||||
#endif
|
||||
|
||||
//==============================================================================
|
||||
/** This static constant is used for referring to an 'invalid' file. */
|
||||
static const File nonexistent;
|
||||
|
||||
//==============================================================================
|
||||
/** Checks whether the file actually exists.
|
||||
|
||||
@returns true if the file exists, either as a file or a directory.
|
||||
@see existsAsFile, isDirectory
|
||||
*/
|
||||
bool exists() const;
|
||||
|
||||
/** Checks whether the file exists and is a file rather than a directory.
|
||||
|
||||
@returns true only if this is a real file, false if it's a directory
|
||||
or doesn't exist
|
||||
@see exists, isDirectory
|
||||
*/
|
||||
bool existsAsFile() const;
|
||||
|
||||
/** Checks whether the file is a directory that exists.
|
||||
|
||||
@returns true only if the file is a directory which actually exists, so
|
||||
false if it's a file or doesn't exist at all
|
||||
@see exists, existsAsFile
|
||||
*/
|
||||
bool isDirectory() const;
|
||||
|
||||
/** Returns the size of the file in bytes.
|
||||
|
||||
@returns the number of bytes in the file, or 0 if it doesn't exist.
|
||||
*/
|
||||
int64 getSize() const;
|
||||
|
||||
/** Utility function to convert a file size in bytes to a neat string description.
|
||||
|
||||
So for example 100 would return "100 bytes", 2000 would return "2 KB",
|
||||
2000000 would produce "2 MB", etc.
|
||||
*/
|
||||
static String descriptionOfSizeInBytes (int64 bytes);
|
||||
|
||||
//==============================================================================
|
||||
/** Returns the complete, absolute path of this file.
|
||||
|
||||
This includes the filename and all its parent folders. On Windows it'll
|
||||
also include the drive letter prefix; on Mac or Linux it'll be a complete
|
||||
path starting from the root folder.
|
||||
|
||||
If you just want the file's name, you should use getFileName() or
|
||||
getFileNameWithoutExtension().
|
||||
|
||||
@see getFileName, getRelativePathFrom
|
||||
*/
|
||||
const String& getFullPathName() const noexcept { return fullPath; }
|
||||
|
||||
/** Returns the last section of the pathname.
|
||||
|
||||
Returns just the final part of the path - e.g. if the whole path
|
||||
is "/moose/fish/foo.txt" this will return "foo.txt".
|
||||
|
||||
For a directory, it returns the final part of the path - e.g. for the
|
||||
directory "/moose/fish" it'll return "fish".
|
||||
|
||||
If the filename begins with a dot, it'll return the whole filename, e.g. for
|
||||
"/moose/.fish", it'll return ".fish"
|
||||
|
||||
@see getFullPathName, getFileNameWithoutExtension
|
||||
*/
|
||||
String getFileName() const;
|
||||
|
||||
/** Creates a relative path that refers to a file relatively to a given directory.
|
||||
|
||||
e.g. File ("/moose/foo.txt").getRelativePathFrom (File ("/moose/fish/haddock"))
|
||||
would return "../../foo.txt".
|
||||
|
||||
If it's not possible to navigate from one file to the other, an absolute
|
||||
path is returned. If the paths are invalid, an empty string may also be
|
||||
returned.
|
||||
|
||||
@param directoryToBeRelativeTo the directory which the resultant string will
|
||||
be relative to. If this is actually a file rather than
|
||||
a directory, its parent directory will be used instead.
|
||||
If it doesn't exist, it's assumed to be a directory.
|
||||
@see getChildFile, isAbsolutePath
|
||||
*/
|
||||
String getRelativePathFrom (const File& directoryToBeRelativeTo) const;
|
||||
|
||||
//==============================================================================
|
||||
/** Returns the file's extension.
|
||||
|
||||
Returns the file extension of this file, also including the dot.
|
||||
|
||||
e.g. "/moose/fish/foo.txt" would return ".txt"
|
||||
|
||||
@see hasFileExtension, withFileExtension, getFileNameWithoutExtension
|
||||
*/
|
||||
String getFileExtension() const;
|
||||
|
||||
/** Checks whether the file has a given extension.
|
||||
|
||||
@param extensionToTest the extension to look for - it doesn't matter whether or
|
||||
not this string has a dot at the start, so ".wav" and "wav"
|
||||
will have the same effect. To compare with multiple extensions, this
|
||||
parameter can contain multiple strings, separated by semi-colons -
|
||||
so, for example: hasFileExtension (".jpeg;png;gif") would return
|
||||
true if the file has any of those three extensions.
|
||||
|
||||
@see getFileExtension, withFileExtension, getFileNameWithoutExtension
|
||||
*/
|
||||
bool hasFileExtension (StringRef extensionToTest) const;
|
||||
|
||||
/** Returns a version of this file with a different file extension.
|
||||
|
||||
e.g. File ("/moose/fish/foo.txt").withFileExtension ("html") returns "/moose/fish/foo.html"
|
||||
|
||||
@param newExtension the new extension, either with or without a dot at the start (this
|
||||
doesn't make any difference). To get remove a file's extension altogether,
|
||||
pass an empty string into this function.
|
||||
|
||||
@see getFileName, getFileExtension, hasFileExtension, getFileNameWithoutExtension
|
||||
*/
|
||||
File withFileExtension (StringRef newExtension) const;
|
||||
|
||||
/** Returns the last part of the filename, without its file extension.
|
||||
|
||||
e.g. for "/moose/fish/foo.txt" this will return "foo".
|
||||
|
||||
@see getFileName, getFileExtension, hasFileExtension, withFileExtension
|
||||
*/
|
||||
String getFileNameWithoutExtension() const;
|
||||
|
||||
//==============================================================================
|
||||
/** Returns a 32-bit hash-code that identifies this file.
|
||||
|
||||
This is based on the filename. Obviously it's possible, although unlikely, that
|
||||
two files will have the same hash-code.
|
||||
*/
|
||||
int hashCode() const;
|
||||
|
||||
/** Returns a 64-bit hash-code that identifies this file.
|
||||
|
||||
This is based on the filename. Obviously it's possible, although unlikely, that
|
||||
two files will have the same hash-code.
|
||||
*/
|
||||
int64 hashCode64() const;
|
||||
|
||||
//==============================================================================
|
||||
/** Returns a file that represents a relative (or absolute) sub-path of the current one.
|
||||
|
||||
This will find a child file or directory of the current object.
|
||||
|
||||
e.g.
|
||||
File ("/moose/fish").getChildFile ("foo.txt") will produce "/moose/fish/foo.txt".
|
||||
File ("/moose/fish").getChildFile ("haddock/foo.txt") will produce "/moose/fish/haddock/foo.txt".
|
||||
File ("/moose/fish").getChildFile ("../foo.txt") will produce "/moose/foo.txt".
|
||||
|
||||
If the string is actually an absolute path, it will be treated as such, e.g.
|
||||
File ("/moose/fish").getChildFile ("/foo.txt") will produce "/foo.txt"
|
||||
|
||||
@see getSiblingFile, getParentDirectory, getRelativePathFrom, isAChildOf
|
||||
*/
|
||||
File getChildFile (StringRef relativeOrAbsolutePath) const;
|
||||
|
||||
/** Returns a file which is in the same directory as this one.
|
||||
|
||||
This is equivalent to getParentDirectory().getChildFile (name).
|
||||
|
||||
@see getChildFile, getParentDirectory
|
||||
*/
|
||||
File getSiblingFile (StringRef siblingFileName) const;
|
||||
|
||||
//==============================================================================
|
||||
/** Returns the directory that contains this file or directory.
|
||||
|
||||
e.g. for "/moose/fish/foo.txt" this will return "/moose/fish".
|
||||
*/
|
||||
File getParentDirectory() const;
|
||||
|
||||
/** Checks whether a file is somewhere inside a directory.
|
||||
|
||||
Returns true if this file is somewhere inside a subdirectory of the directory
|
||||
that is passed in. Neither file actually has to exist, because the function
|
||||
just checks the paths for similarities.
|
||||
|
||||
e.g. File ("/moose/fish/foo.txt").isAChildOf ("/moose") is true.
|
||||
File ("/moose/fish/foo.txt").isAChildOf ("/moose/fish") is also true.
|
||||
*/
|
||||
bool isAChildOf (const File& potentialParentDirectory) const;
|
||||
|
||||
//==============================================================================
|
||||
/** Chooses a filename relative to this one that doesn't already exist.
|
||||
|
||||
If this file is a directory, this will return a child file of this
|
||||
directory that doesn't exist, by adding numbers to a prefix and suffix until
|
||||
it finds one that isn't already there.
|
||||
|
||||
If the prefix + the suffix doesn't exist, it won't bother adding a number.
|
||||
|
||||
e.g. File ("/moose/fish").getNonexistentChildFile ("foo", ".txt", true) might
|
||||
return "/moose/fish/foo(2).txt" if there's already a file called "foo.txt".
|
||||
|
||||
@param prefix the string to use for the filename before the number
|
||||
@param suffix the string to add to the filename after the number
|
||||
@param putNumbersInBrackets if true, this will create filenames in the
|
||||
format "prefix(number)suffix", if false, it will leave the
|
||||
brackets out.
|
||||
*/
|
||||
File getNonexistentChildFile (const String& prefix,
|
||||
const String& suffix,
|
||||
bool putNumbersInBrackets = true) const;
|
||||
|
||||
/** Chooses a filename for a sibling file to this one that doesn't already exist.
|
||||
|
||||
If this file doesn't exist, this will just return itself, otherwise it
|
||||
will return an appropriate sibling that doesn't exist, e.g. if a file
|
||||
"/moose/fish/foo.txt" exists, this might return "/moose/fish/foo(2).txt".
|
||||
|
||||
@param putNumbersInBrackets whether to add brackets around the numbers that
|
||||
get appended to the new filename.
|
||||
*/
|
||||
File getNonexistentSibling (bool putNumbersInBrackets = true) const;
|
||||
|
||||
//==============================================================================
|
||||
/** Compares the pathnames for two files. */
|
||||
bool operator== (const File&) const;
|
||||
/** Compares the pathnames for two files. */
|
||||
bool operator!= (const File&) const;
|
||||
/** Compares the pathnames for two files. */
|
||||
bool operator< (const File&) const;
|
||||
/** Compares the pathnames for two files. */
|
||||
bool operator> (const File&) const;
|
||||
|
||||
//==============================================================================
|
||||
/** Checks whether a file can be created or written to.
|
||||
|
||||
@returns true if it's possible to create and write to this file. If the file
|
||||
doesn't already exist, this will check its parent directory to
|
||||
see if writing is allowed.
|
||||
@see setReadOnly
|
||||
*/
|
||||
bool hasWriteAccess() const;
|
||||
|
||||
/** Changes the write-permission of a file or directory.
|
||||
|
||||
@param shouldBeReadOnly whether to add or remove write-permission
|
||||
@param applyRecursively if the file is a directory and this is true, it will
|
||||
recurse through all the subfolders changing the permissions
|
||||
of all files
|
||||
@returns true if it manages to change the file's permissions.
|
||||
@see hasWriteAccess
|
||||
*/
|
||||
bool setReadOnly (bool shouldBeReadOnly,
|
||||
bool applyRecursively = false) const;
|
||||
|
||||
/** Changes the execute-permissions of a file.
|
||||
|
||||
@param shouldBeExecutable whether to add or remove execute-permission
|
||||
@returns true if it manages to change the file's permissions.
|
||||
*/
|
||||
bool setExecutePermission (bool shouldBeExecutable) const;
|
||||
|
||||
/** Returns true if this file is a hidden or system file.
|
||||
The criteria for deciding whether a file is hidden are platform-dependent.
|
||||
*/
|
||||
bool isHidden() const;
|
||||
|
||||
/** Returns true if this file is a link or alias that can be followed using getLinkedTarget(). */
|
||||
bool isLink() const;
|
||||
|
||||
/** If this file is a link or alias, this returns the file that it points to.
|
||||
If the file isn't actually link, it'll just return itself.
|
||||
*/
|
||||
File getLinkedTarget() const;
|
||||
|
||||
/** Returns a unique identifier for the file, if one is available.
|
||||
|
||||
Depending on the OS and file-system, this may be a unix inode number or
|
||||
a win32 file identifier, or 0 if it fails to find one. The number will
|
||||
be unique on the filesystem, but not globally.
|
||||
*/
|
||||
uint64 getFileIdentifier() const;
|
||||
|
||||
//==============================================================================
|
||||
/** Returns the last modification time of this file.
|
||||
|
||||
@returns the time, or an invalid time if the file doesn't exist.
|
||||
@see setLastModificationTime, getLastAccessTime, getCreationTime
|
||||
*/
|
||||
Time getLastModificationTime() const;
|
||||
|
||||
/** Returns the last time this file was accessed.
|
||||
|
||||
@returns the time, or an invalid time if the file doesn't exist.
|
||||
@see setLastAccessTime, getLastModificationTime, getCreationTime
|
||||
*/
|
||||
Time getLastAccessTime() const;
|
||||
|
||||
/** Returns the time that this file was created.
|
||||
|
||||
@returns the time, or an invalid time if the file doesn't exist.
|
||||
@see getLastModificationTime, getLastAccessTime
|
||||
*/
|
||||
Time getCreationTime() const;
|
||||
|
||||
/** Changes the modification time for this file.
|
||||
|
||||
@param newTime the time to apply to the file
|
||||
@returns true if it manages to change the file's time.
|
||||
@see getLastModificationTime, setLastAccessTime, setCreationTime
|
||||
*/
|
||||
bool setLastModificationTime (Time newTime) const;
|
||||
|
||||
/** Changes the last-access time for this file.
|
||||
|
||||
@param newTime the time to apply to the file
|
||||
@returns true if it manages to change the file's time.
|
||||
@see getLastAccessTime, setLastModificationTime, setCreationTime
|
||||
*/
|
||||
bool setLastAccessTime (Time newTime) const;
|
||||
|
||||
/** Changes the creation date for this file.
|
||||
|
||||
@param newTime the time to apply to the file
|
||||
@returns true if it manages to change the file's time.
|
||||
@see getCreationTime, setLastModificationTime, setLastAccessTime
|
||||
*/
|
||||
bool setCreationTime (Time newTime) const;
|
||||
|
||||
/** If possible, this will try to create a version string for the given file.
|
||||
|
||||
The OS may be able to look at the file and give a version for it - e.g. with
|
||||
executables, bundles, dlls, etc. If no version is available, this will
|
||||
return an empty string.
|
||||
*/
|
||||
String getVersion() const;
|
||||
|
||||
//==============================================================================
|
||||
/** Creates an empty file if it doesn't already exist.
|
||||
|
||||
If the file that this object refers to doesn't exist, this will create a file
|
||||
of zero size.
|
||||
|
||||
If it already exists or is a directory, this method will do nothing.
|
||||
|
||||
@returns true if the file has been created (or if it already existed).
|
||||
@see createDirectory
|
||||
*/
|
||||
Result create() const;
|
||||
|
||||
/** Creates a new directory for this filename.
|
||||
|
||||
This will try to create the file as a directory, and fill also create
|
||||
any parent directories it needs in order to complete the operation.
|
||||
|
||||
@returns a result to indicate whether the directory was created successfully, or
|
||||
an error message if it failed.
|
||||
@see create
|
||||
*/
|
||||
Result createDirectory() const;
|
||||
|
||||
/** Deletes a file.
|
||||
|
||||
If this file is actually a directory, it may not be deleted correctly if it
|
||||
contains files. See deleteRecursively() as a better way of deleting directories.
|
||||
|
||||
@returns true if the file has been successfully deleted (or if it didn't exist to
|
||||
begin with).
|
||||
@see deleteRecursively
|
||||
*/
|
||||
bool deleteFile() const;
|
||||
|
||||
/** Deletes a file or directory and all its subdirectories.
|
||||
|
||||
If this file is a directory, this will try to delete it and all its subfolders. If
|
||||
it's just a file, it will just try to delete the file.
|
||||
|
||||
@returns true if the file and all its subfolders have been successfully deleted
|
||||
(or if it didn't exist to begin with).
|
||||
@see deleteFile
|
||||
*/
|
||||
bool deleteRecursively() const;
|
||||
|
||||
/** Moves this file or folder to the trash.
|
||||
|
||||
@returns true if the operation succeeded. It could fail if the trash is full, or
|
||||
if the file is write-protected, so you should check the return value
|
||||
and act appropriately.
|
||||
*/
|
||||
bool moveToTrash() const;
|
||||
|
||||
/** Moves or renames a file.
|
||||
|
||||
Tries to move a file to a different location.
|
||||
If the target file already exists, this will attempt to delete it first, and
|
||||
will fail if this can't be done.
|
||||
|
||||
Note that the destination file isn't the directory to put it in, it's the actual
|
||||
filename that you want the new file to have.
|
||||
|
||||
@returns true if the operation succeeds
|
||||
*/
|
||||
bool moveFileTo (const File& targetLocation) const;
|
||||
|
||||
/** Copies a file.
|
||||
|
||||
Tries to copy a file to a different location.
|
||||
If the target file already exists, this will attempt to delete it first, and
|
||||
will fail if this can't be done.
|
||||
|
||||
@returns true if the operation succeeds
|
||||
*/
|
||||
bool copyFileTo (const File& targetLocation) const;
|
||||
|
||||
/** Copies a directory.
|
||||
|
||||
Tries to copy an entire directory, recursively.
|
||||
|
||||
If this file isn't a directory or if any target files can't be created, this
|
||||
will return false.
|
||||
|
||||
@param newDirectory the directory that this one should be copied to. Note that this
|
||||
is the name of the actual directory to create, not the directory
|
||||
into which the new one should be placed, so there must be enough
|
||||
write privileges to create it if it doesn't exist. Any files inside
|
||||
it will be overwritten by similarly named ones that are copied.
|
||||
*/
|
||||
bool copyDirectoryTo (const File& newDirectory) const;
|
||||
|
||||
//==============================================================================
|
||||
/** Used in file searching, to specify whether to return files, directories, or both.
|
||||
*/
|
||||
enum TypesOfFileToFind
|
||||
{
|
||||
findDirectories = 1, /**< Use this flag to indicate that you want to find directories. */
|
||||
findFiles = 2, /**< Use this flag to indicate that you want to find files. */
|
||||
findFilesAndDirectories = 3, /**< Use this flag to indicate that you want to find both files and directories. */
|
||||
ignoreHiddenFiles = 4 /**< Add this flag to avoid returning any hidden files in the results. */
|
||||
};
|
||||
|
||||
/** Searches inside a directory for files matching a wildcard pattern.
|
||||
|
||||
Assuming that this file is a directory, this method will search it
|
||||
for either files or subdirectories whose names match a filename pattern.
|
||||
|
||||
@param results an array to which File objects will be added for the
|
||||
files that the search comes up with
|
||||
@param whatToLookFor a value from the TypesOfFileToFind enum, specifying whether to
|
||||
return files, directories, or both. If the ignoreHiddenFiles flag
|
||||
is also added to this value, hidden files won't be returned
|
||||
@param searchRecursively if true, all subdirectories will be recursed into to do
|
||||
an exhaustive search
|
||||
@param wildCardPattern the filename pattern to search for, e.g. "*.txt"
|
||||
@returns the number of results that have been found
|
||||
|
||||
@see getNumberOfChildFiles, DirectoryIterator
|
||||
*/
|
||||
int findChildFiles (Array<File>& results,
|
||||
int whatToLookFor,
|
||||
bool searchRecursively,
|
||||
const String& wildCardPattern = "*") const;
|
||||
|
||||
/** Searches inside a directory and counts how many files match a wildcard pattern.
|
||||
|
||||
Assuming that this file is a directory, this method will search it
|
||||
for either files or subdirectories whose names match a filename pattern,
|
||||
and will return the number of matches found.
|
||||
|
||||
This isn't a recursive call, and will only search this directory, not
|
||||
its children.
|
||||
|
||||
@param whatToLookFor a value from the TypesOfFileToFind enum, specifying whether to
|
||||
count files, directories, or both. If the ignoreHiddenFiles flag
|
||||
is also added to this value, hidden files won't be counted
|
||||
@param wildCardPattern the filename pattern to search for, e.g. "*.txt"
|
||||
@returns the number of matches found
|
||||
@see findChildFiles, DirectoryIterator
|
||||
*/
|
||||
int getNumberOfChildFiles (int whatToLookFor,
|
||||
const String& wildCardPattern = "*") const;
|
||||
|
||||
/** Returns true if this file is a directory that contains one or more subdirectories.
|
||||
@see isDirectory, findChildFiles
|
||||
*/
|
||||
bool containsSubDirectories() const;
|
||||
|
||||
//==============================================================================
|
||||
/** Creates a stream to read from this file.
|
||||
|
||||
@returns a stream that will read from this file (initially positioned at the
|
||||
start of the file), or nullptr if the file can't be opened for some reason
|
||||
@see createOutputStream, loadFileAsData
|
||||
*/
|
||||
FileInputStream* createInputStream() const;
|
||||
|
||||
/** Creates a stream to write to this file.
|
||||
|
||||
If the file exists, the stream that is returned will be positioned ready for
|
||||
writing at the end of the file, so you might want to use deleteFile() first
|
||||
to write to an empty file.
|
||||
|
||||
@returns a stream that will write to this file (initially positioned at the
|
||||
end of the file), or nullptr if the file can't be opened for some reason
|
||||
@see createInputStream, appendData, appendText
|
||||
*/
|
||||
FileOutputStream* createOutputStream (size_t bufferSize = 0x8000) const;
|
||||
|
||||
//==============================================================================
|
||||
/** Loads a file's contents into memory as a block of binary data.
|
||||
|
||||
Of course, trying to load a very large file into memory will blow up, so
|
||||
it's better to check first.
|
||||
|
||||
@param result the data block to which the file's contents should be appended - note
|
||||
that if the memory block might already contain some data, you
|
||||
might want to clear it first
|
||||
@returns true if the file could all be read into memory
|
||||
*/
|
||||
bool loadFileAsData (MemoryBlock& result) const;
|
||||
|
||||
/** Reads a file into memory as a string.
|
||||
|
||||
Attempts to load the entire file as a zero-terminated string.
|
||||
|
||||
This makes use of InputStream::readEntireStreamAsString, which can
|
||||
read either UTF-16 or UTF-8 file formats.
|
||||
*/
|
||||
String loadFileAsString() const;
|
||||
|
||||
/** Reads the contents of this file as text and splits it into lines, which are
|
||||
appended to the given StringArray.
|
||||
*/
|
||||
void readLines (StringArray& destLines) const;
|
||||
|
||||
//==============================================================================
|
||||
/** Appends a block of binary data to the end of the file.
|
||||
|
||||
This will try to write the given buffer to the end of the file.
|
||||
|
||||
@returns false if it can't write to the file for some reason
|
||||
*/
|
||||
bool appendData (const void* dataToAppend,
|
||||
size_t numberOfBytes) const;
|
||||
|
||||
/** Replaces this file's contents with a given block of data.
|
||||
|
||||
This will delete the file and replace it with the given data.
|
||||
|
||||
A nice feature of this method is that it's safe - instead of deleting
|
||||
the file first and then re-writing it, it creates a new temporary file,
|
||||
writes the data to that, and then moves the new file to replace the existing
|
||||
file. This means that if the power gets pulled out or something crashes,
|
||||
you're a lot less likely to end up with a corrupted or unfinished file..
|
||||
|
||||
Returns true if the operation succeeds, or false if it fails.
|
||||
|
||||
@see appendText
|
||||
*/
|
||||
bool replaceWithData (const void* dataToWrite,
|
||||
size_t numberOfBytes) const;
|
||||
|
||||
/** Appends a string to the end of the file.
|
||||
|
||||
This will try to append a text string to the file, as either 16-bit unicode
|
||||
or 8-bit characters in the default system encoding.
|
||||
|
||||
It can also write the 'ff fe' unicode header bytes before the text to indicate
|
||||
the endianness of the file.
|
||||
|
||||
Any single \\n characters in the string are replaced with \\r\\n before it is written.
|
||||
|
||||
@see replaceWithText
|
||||
*/
|
||||
bool appendText (const String& textToAppend,
|
||||
bool asUnicode = false,
|
||||
bool writeUnicodeHeaderBytes = false) const;
|
||||
|
||||
/** Replaces this file's contents with a given text string.
|
||||
|
||||
This will delete the file and replace it with the given text.
|
||||
|
||||
A nice feature of this method is that it's safe - instead of deleting
|
||||
the file first and then re-writing it, it creates a new temporary file,
|
||||
writes the text to that, and then moves the new file to replace the existing
|
||||
file. This means that if the power gets pulled out or something crashes,
|
||||
you're a lot less likely to end up with an empty file..
|
||||
|
||||
For an explanation of the parameters here, see the appendText() method.
|
||||
|
||||
Returns true if the operation succeeds, or false if it fails.
|
||||
|
||||
@see appendText
|
||||
*/
|
||||
bool replaceWithText (const String& textToWrite,
|
||||
bool asUnicode = false,
|
||||
bool writeUnicodeHeaderBytes = false) const;
|
||||
|
||||
/** Attempts to scan the contents of this file and compare it to another file, returning
|
||||
true if this is possible and they match byte-for-byte.
|
||||
*/
|
||||
bool hasIdenticalContentTo (const File& other) const;
|
||||
|
||||
//==============================================================================
|
||||
/** Creates a set of files to represent each file root.
|
||||
|
||||
e.g. on Windows this will create files for "c:\", "d:\" etc according
|
||||
to which ones are available. On the Mac/Linux, this will probably
|
||||
just add a single entry for "/".
|
||||
*/
|
||||
static void findFileSystemRoots (Array<File>& results);
|
||||
|
||||
/** Finds the name of the drive on which this file lives.
|
||||
@returns the volume label of the drive, or an empty string if this isn't possible
|
||||
*/
|
||||
String getVolumeLabel() const;
|
||||
|
||||
/** Returns the serial number of the volume on which this file lives.
|
||||
@returns the serial number, or zero if there's a problem doing this
|
||||
*/
|
||||
int getVolumeSerialNumber() const;
|
||||
|
||||
/** Returns the number of bytes free on the drive that this file lives on.
|
||||
|
||||
@returns the number of bytes free, or 0 if there's a problem finding this out
|
||||
@see getVolumeTotalSize
|
||||
*/
|
||||
int64 getBytesFreeOnVolume() const;
|
||||
|
||||
/** Returns the total size of the drive that contains this file.
|
||||
|
||||
@returns the total number of bytes that the volume can hold
|
||||
@see getBytesFreeOnVolume
|
||||
*/
|
||||
int64 getVolumeTotalSize() const;
|
||||
|
||||
/** Returns true if this file is on a CD or DVD drive. */
|
||||
bool isOnCDRomDrive() const;
|
||||
|
||||
/** Returns true if this file is on a hard disk.
|
||||
|
||||
This will fail if it's a network drive, but will still be true for
|
||||
removable hard-disks.
|
||||
*/
|
||||
bool isOnHardDisk() const;
|
||||
|
||||
/** Returns true if this file is on a removable disk drive.
|
||||
|
||||
This might be a usb-drive, a CD-rom, or maybe a network drive.
|
||||
*/
|
||||
bool isOnRemovableDrive() const;
|
||||
|
||||
//==============================================================================
|
||||
/** Launches the file as a process.
|
||||
|
||||
- if the file is executable, this will run it.
|
||||
|
||||
- if it's a document of some kind, it will launch the document with its
|
||||
default viewer application.
|
||||
|
||||
- if it's a folder, it will be opened in Explorer, Finder, or equivalent.
|
||||
|
||||
@see revealToUser
|
||||
*/
|
||||
bool startAsProcess (const String& parameters = String()) const;
|
||||
|
||||
/** Opens Finder, Explorer, or whatever the OS uses, to show the user this file's location.
|
||||
@see startAsProcess
|
||||
*/
|
||||
void revealToUser() const;
|
||||
|
||||
//==============================================================================
|
||||
/** A set of types of location that can be passed to the getSpecialLocation() method.
|
||||
*/
|
||||
enum SpecialLocationType
|
||||
{
|
||||
/** The user's home folder. This is the same as using File ("~"). */
|
||||
userHomeDirectory,
|
||||
|
||||
/** The user's default documents folder. On Windows, this might be the user's
|
||||
"My Documents" folder. On the Mac it'll be their "Documents" folder. Linux
|
||||
doesn't tend to have one of these, so it might just return their home folder.
|
||||
*/
|
||||
userDocumentsDirectory,
|
||||
|
||||
/** The folder that contains the user's desktop objects. */
|
||||
userDesktopDirectory,
|
||||
|
||||
/** The most likely place where a user might store their music files. */
|
||||
userMusicDirectory,
|
||||
|
||||
/** The most likely place where a user might store their movie files. */
|
||||
userMoviesDirectory,
|
||||
|
||||
/** The most likely place where a user might store their picture files. */
|
||||
userPicturesDirectory,
|
||||
|
||||
/** The folder in which applications store their persistent user-specific settings.
|
||||
On Windows, this might be "\Documents and Settings\username\Application Data".
|
||||
On the Mac, it might be "~/Library". If you're going to store your settings in here,
|
||||
always create your own sub-folder to put them in, to avoid making a mess.
|
||||
*/
|
||||
userApplicationDataDirectory,
|
||||
|
||||
/** An equivalent of the userApplicationDataDirectory folder that is shared by all users
|
||||
of the computer, rather than just the current user.
|
||||
|
||||
On the Mac it'll be "/Library", on Windows, it could be something like
|
||||
"\Documents and Settings\All Users\Application Data".
|
||||
|
||||
Depending on the setup, this folder may be read-only.
|
||||
*/
|
||||
commonApplicationDataDirectory,
|
||||
|
||||
/** A place to put documents which are shared by all users of the machine.
|
||||
On Windows this may be somewhere like "C:\Users\Public\Documents", on OSX it
|
||||
will be something like "/Users/Shared". Other OSes may have no such concept
|
||||
though, so be careful.
|
||||
*/
|
||||
commonDocumentsDirectory,
|
||||
|
||||
/** The folder that should be used for temporary files.
|
||||
Always delete them when you're finished, to keep the user's computer tidy!
|
||||
*/
|
||||
tempDirectory,
|
||||
|
||||
/** Returns this application's executable file.
|
||||
|
||||
If running as a plug-in or DLL, this will (where possible) be the DLL rather than the
|
||||
host app.
|
||||
|
||||
On the mac this will return the unix binary, not the package folder - see
|
||||
currentApplicationFile for that.
|
||||
|
||||
See also invokedExecutableFile, which is similar, but if the exe was launched from a
|
||||
file link, invokedExecutableFile will return the name of the link.
|
||||
*/
|
||||
currentExecutableFile,
|
||||
|
||||
/** Returns this application's location.
|
||||
|
||||
If running as a plug-in or DLL, this will (where possible) be the DLL rather than the
|
||||
host app.
|
||||
|
||||
On the mac this will return the package folder (if it's in one), not the unix binary
|
||||
that's inside it - compare with currentExecutableFile.
|
||||
*/
|
||||
currentApplicationFile,
|
||||
|
||||
/** Returns the file that was invoked to launch this executable.
|
||||
This may differ from currentExecutableFile if the app was started from e.g. a link - this
|
||||
will return the name of the link that was used, whereas currentExecutableFile will return
|
||||
the actual location of the target executable.
|
||||
*/
|
||||
invokedExecutableFile,
|
||||
|
||||
/** In a plugin, this will return the path of the host executable. */
|
||||
hostApplicationPath,
|
||||
|
||||
#if JUCE_WINDOWS
|
||||
/** On a Windows machine, returns the location of the Windows/System32 folder. */
|
||||
windowsSystemDirectory,
|
||||
#endif
|
||||
|
||||
/** The directory in which applications normally get installed.
|
||||
So on windows, this would be something like "c:\program files", on the
|
||||
Mac "/Applications", or "/usr" on linux.
|
||||
*/
|
||||
globalApplicationsDirectory
|
||||
};
|
||||
|
||||
/** Finds the location of a special type of file or directory, such as a home folder or
|
||||
documents folder.
|
||||
|
||||
@see SpecialLocationType
|
||||
*/
|
||||
static File JUCE_CALLTYPE getSpecialLocation (const SpecialLocationType type);
|
||||
|
||||
//==============================================================================
|
||||
/** Returns a temporary file in the system's temp directory.
|
||||
This will try to return the name of a non-existent temp file.
|
||||
To get the temp folder, you can use getSpecialLocation (File::tempDirectory).
|
||||
*/
|
||||
static File createTempFile (StringRef fileNameEnding);
|
||||
|
||||
|
||||
//==============================================================================
|
||||
/** Returns the current working directory.
|
||||
@see setAsCurrentWorkingDirectory
|
||||
*/
|
||||
static File getCurrentWorkingDirectory();
|
||||
|
||||
/** Sets the current working directory to be this file.
|
||||
|
||||
For this to work the file must point to a valid directory.
|
||||
|
||||
@returns true if the current directory has been changed.
|
||||
@see getCurrentWorkingDirectory
|
||||
*/
|
||||
bool setAsCurrentWorkingDirectory() const;
|
||||
|
||||
//==============================================================================
|
||||
/** The system-specific file separator character.
|
||||
On Windows, this will be '\', on Mac/Linux, it'll be '/'
|
||||
*/
|
||||
static const juce_wchar separator;
|
||||
|
||||
/** The system-specific file separator character, as a string.
|
||||
On Windows, this will be '\', on Mac/Linux, it'll be '/'
|
||||
*/
|
||||
static const String separatorString;
|
||||
|
||||
//==============================================================================
|
||||
/** Returns a version of a filename with any illegal characters removed.
|
||||
|
||||
This will return a copy of the given string after removing characters
|
||||
that are not allowed in a legal filename, and possibly shortening the
|
||||
string if it's too long.
|
||||
|
||||
Because this will remove slashes, don't use it on an absolute pathname - use
|
||||
createLegalPathName() for that.
|
||||
|
||||
@see createLegalPathName
|
||||
*/
|
||||
static String createLegalFileName (const String& fileNameToFix);
|
||||
|
||||
/** Returns a version of a path with any illegal characters removed.
|
||||
|
||||
Similar to createLegalFileName(), but this won't remove slashes, so can
|
||||
be used on a complete pathname.
|
||||
|
||||
@see createLegalFileName
|
||||
*/
|
||||
static String createLegalPathName (const String& pathNameToFix);
|
||||
|
||||
/** Indicates whether filenames are case-sensitive on the current operating system. */
|
||||
static bool areFileNamesCaseSensitive();
|
||||
|
||||
/** Returns true if the string seems to be a fully-specified absolute path. */
|
||||
static bool isAbsolutePath (StringRef path);
|
||||
|
||||
/** Creates a file that simply contains this string, without doing the sanity-checking
|
||||
that the normal constructors do.
|
||||
|
||||
Best to avoid this unless you really know what you're doing.
|
||||
*/
|
||||
static File createFileWithoutCheckingPath (const String& absolutePath) noexcept;
|
||||
|
||||
/** Adds a separator character to the end of a path if it doesn't already have one. */
|
||||
static String addTrailingSeparator (const String& path);
|
||||
|
||||
#if JUCE_MAC || JUCE_IOS || DOXYGEN
|
||||
//==============================================================================
|
||||
/** OSX ONLY - Finds the OSType of a file from the its resources. */
|
||||
OSType getMacOSType() const;
|
||||
|
||||
/** OSX ONLY - Returns true if this file is actually a bundle. */
|
||||
bool isBundle() const;
|
||||
#endif
|
||||
|
||||
#if JUCE_MAC || DOXYGEN
|
||||
/** OSX ONLY - Adds this file to the OSX dock */
|
||||
void addToDock() const;
|
||||
#endif
|
||||
|
||||
#if JUCE_WINDOWS
|
||||
/** Windows ONLY - Creates a win32 .LNK shortcut file that links to this file. */
|
||||
bool createLink (const String& description, const File& linkFileToCreate) const;
|
||||
#endif
|
||||
|
||||
private:
|
||||
//==============================================================================
|
||||
String fullPath;
|
||||
|
||||
static String parseAbsolutePath (const String&);
|
||||
String getPathUpToLastSlash() const;
|
||||
|
||||
Result createDirectoryInternal (const String&) const;
|
||||
bool copyInternal (const File&) const;
|
||||
bool moveInternal (const File&) const;
|
||||
bool setFileTimesInternal (int64 m, int64 a, int64 c) const;
|
||||
void getFileTimesInternal (int64& m, int64& a, int64& c) const;
|
||||
bool setFileReadOnlyInternal (bool) const;
|
||||
bool setFileExecutableInternal (bool) const;
|
||||
};
|
||||
|
||||
#endif // JUCE_FILE_H_INCLUDED
|
||||
@@ -0,0 +1,41 @@
|
||||
/*
|
||||
==============================================================================
|
||||
|
||||
This file is part of the juce_core module of the JUCE library.
|
||||
Copyright (c) 2013 - Raw Material Software Ltd.
|
||||
|
||||
Permission to use, copy, modify, and/or distribute this software for any purpose with
|
||||
or without fee is hereby granted, provided that the above copyright notice and this
|
||||
permission notice appear in all copies.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
|
||||
TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN
|
||||
NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
|
||||
DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
|
||||
IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
|
||||
CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
|
||||
NOTE! This permissive ISC license applies ONLY to files within the juce_core module!
|
||||
All other JUCE modules are covered by a dual GPL/commercial license, so if you are
|
||||
using any other modules, be sure to check that you also comply with their license.
|
||||
|
||||
For more details, visit www.juce.com
|
||||
|
||||
==============================================================================
|
||||
*/
|
||||
|
||||
FileFilter::FileFilter (const String& filterDescription)
|
||||
: description (filterDescription)
|
||||
{
|
||||
}
|
||||
|
||||
FileFilter::~FileFilter()
|
||||
{
|
||||
}
|
||||
|
||||
const String& FileFilter::getDescription() const noexcept
|
||||
{
|
||||
return description;
|
||||
}
|
||||
@@ -0,0 +1,77 @@
|
||||
/*
|
||||
==============================================================================
|
||||
|
||||
This file is part of the juce_core module of the JUCE library.
|
||||
Copyright (c) 2013 - Raw Material Software Ltd.
|
||||
|
||||
Permission to use, copy, modify, and/or distribute this software for any purpose with
|
||||
or without fee is hereby granted, provided that the above copyright notice and this
|
||||
permission notice appear in all copies.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
|
||||
TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN
|
||||
NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
|
||||
DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
|
||||
IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
|
||||
CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
|
||||
NOTE! This permissive ISC license applies ONLY to files within the juce_core module!
|
||||
All other JUCE modules are covered by a dual GPL/commercial license, so if you are
|
||||
using any other modules, be sure to check that you also comply with their license.
|
||||
|
||||
For more details, visit www.juce.com
|
||||
|
||||
==============================================================================
|
||||
*/
|
||||
|
||||
#ifndef JUCE_FILEFILTER_H_INCLUDED
|
||||
#define JUCE_FILEFILTER_H_INCLUDED
|
||||
|
||||
|
||||
//==============================================================================
|
||||
/**
|
||||
Interface for deciding which files are suitable for something.
|
||||
|
||||
For example, this is used by DirectoryContentsList to select which files
|
||||
go into the list.
|
||||
|
||||
@see WildcardFileFilter, DirectoryContentsList, FileListComponent, FileBrowserComponent
|
||||
*/
|
||||
class JUCE_API FileFilter
|
||||
{
|
||||
public:
|
||||
//==============================================================================
|
||||
/** Creates a filter with the given description.
|
||||
|
||||
The description can be returned later with the getDescription() method.
|
||||
*/
|
||||
FileFilter (const String& filterDescription);
|
||||
|
||||
/** Destructor. */
|
||||
virtual ~FileFilter();
|
||||
|
||||
//==============================================================================
|
||||
/** Returns the description that the filter was created with. */
|
||||
const String& getDescription() const noexcept;
|
||||
|
||||
//==============================================================================
|
||||
/** Should return true if this file is suitable for inclusion in whatever context
|
||||
the object is being used.
|
||||
*/
|
||||
virtual bool isFileSuitable (const File& file) const = 0;
|
||||
|
||||
/** Should return true if this directory is suitable for inclusion in whatever context
|
||||
the object is being used.
|
||||
*/
|
||||
virtual bool isDirectorySuitable (const File& file) const = 0;
|
||||
|
||||
|
||||
protected:
|
||||
//==============================================================================
|
||||
String description;
|
||||
};
|
||||
|
||||
|
||||
#endif // JUCE_FILEFILTER_H_INCLUDED
|
||||
@@ -0,0 +1,84 @@
|
||||
/*
|
||||
==============================================================================
|
||||
|
||||
This file is part of the juce_core module of the JUCE library.
|
||||
Copyright (c) 2013 - Raw Material Software Ltd.
|
||||
|
||||
Permission to use, copy, modify, and/or distribute this software for any purpose with
|
||||
or without fee is hereby granted, provided that the above copyright notice and this
|
||||
permission notice appear in all copies.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
|
||||
TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN
|
||||
NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
|
||||
DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
|
||||
IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
|
||||
CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
|
||||
NOTE! This permissive ISC license applies ONLY to files within the juce_core module!
|
||||
All other JUCE modules are covered by a dual GPL/commercial license, so if you are
|
||||
using any other modules, be sure to check that you also comply with their license.
|
||||
|
||||
For more details, visit www.juce.com
|
||||
|
||||
==============================================================================
|
||||
*/
|
||||
|
||||
int64 juce_fileSetPosition (void* handle, int64 pos);
|
||||
|
||||
|
||||
//==============================================================================
|
||||
FileInputStream::FileInputStream (const File& f)
|
||||
: file (f),
|
||||
fileHandle (nullptr),
|
||||
currentPosition (0),
|
||||
status (Result::ok())
|
||||
{
|
||||
openHandle();
|
||||
}
|
||||
|
||||
int64 FileInputStream::getTotalLength()
|
||||
{
|
||||
// You should always check that a stream opened successfully before using it!
|
||||
jassert (openedOk());
|
||||
|
||||
return file.getSize();
|
||||
}
|
||||
|
||||
int FileInputStream::read (void* buffer, int bytesToRead)
|
||||
{
|
||||
// You should always check that a stream opened successfully before using it!
|
||||
jassert (openedOk());
|
||||
|
||||
// The buffer should never be null, and a negative size is probably a
|
||||
// sign that something is broken!
|
||||
jassert (buffer != nullptr && bytesToRead >= 0);
|
||||
|
||||
const size_t num = readInternal (buffer, (size_t) bytesToRead);
|
||||
currentPosition += num;
|
||||
|
||||
return (int) num;
|
||||
}
|
||||
|
||||
bool FileInputStream::isExhausted()
|
||||
{
|
||||
return currentPosition >= getTotalLength();
|
||||
}
|
||||
|
||||
int64 FileInputStream::getPosition()
|
||||
{
|
||||
return currentPosition;
|
||||
}
|
||||
|
||||
bool FileInputStream::setPosition (int64 pos)
|
||||
{
|
||||
// You should always check that a stream opened successfully before using it!
|
||||
jassert (openedOk());
|
||||
|
||||
if (pos != currentPosition)
|
||||
currentPosition = juce_fileSetPosition (fileHandle, pos);
|
||||
|
||||
return currentPosition == pos;
|
||||
}
|
||||
@@ -0,0 +1,96 @@
|
||||
/*
|
||||
==============================================================================
|
||||
|
||||
This file is part of the juce_core module of the JUCE library.
|
||||
Copyright (c) 2013 - Raw Material Software Ltd.
|
||||
|
||||
Permission to use, copy, modify, and/or distribute this software for any purpose with
|
||||
or without fee is hereby granted, provided that the above copyright notice and this
|
||||
permission notice appear in all copies.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
|
||||
TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN
|
||||
NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
|
||||
DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
|
||||
IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
|
||||
CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
|
||||
NOTE! This permissive ISC license applies ONLY to files within the juce_core module!
|
||||
All other JUCE modules are covered by a dual GPL/commercial license, so if you are
|
||||
using any other modules, be sure to check that you also comply with their license.
|
||||
|
||||
For more details, visit www.juce.com
|
||||
|
||||
==============================================================================
|
||||
*/
|
||||
|
||||
#ifndef JUCE_FILEINPUTSTREAM_H_INCLUDED
|
||||
#define JUCE_FILEINPUTSTREAM_H_INCLUDED
|
||||
|
||||
|
||||
//==============================================================================
|
||||
/**
|
||||
An input stream that reads from a local file.
|
||||
|
||||
@see InputStream, FileOutputStream, File::createInputStream
|
||||
*/
|
||||
class JUCE_API FileInputStream : public InputStream
|
||||
{
|
||||
public:
|
||||
//==============================================================================
|
||||
/** Creates a FileInputStream to read from the given file.
|
||||
|
||||
After creating a FileInputStream, you should use openedOk() or failedToOpen()
|
||||
to make sure that it's OK before trying to read from it! If it failed, you
|
||||
can call getStatus() to get more error information.
|
||||
*/
|
||||
explicit FileInputStream (const File& fileToRead);
|
||||
|
||||
/** Destructor. */
|
||||
~FileInputStream();
|
||||
|
||||
//==============================================================================
|
||||
/** Returns the file that this stream is reading from. */
|
||||
const File& getFile() const noexcept { return file; }
|
||||
|
||||
/** Returns the status of the file stream.
|
||||
The result will be ok if the file opened successfully. If an error occurs while
|
||||
opening or reading from the file, this will contain an error message.
|
||||
*/
|
||||
const Result& getStatus() const noexcept { return status; }
|
||||
|
||||
/** Returns true if the stream couldn't be opened for some reason.
|
||||
@see getResult()
|
||||
*/
|
||||
bool failedToOpen() const noexcept { return status.failed(); }
|
||||
|
||||
/** Returns true if the stream opened without problems.
|
||||
@see getResult()
|
||||
*/
|
||||
bool openedOk() const noexcept { return status.wasOk(); }
|
||||
|
||||
|
||||
//==============================================================================
|
||||
int64 getTotalLength() override;
|
||||
int read (void*, int) override;
|
||||
bool isExhausted() override;
|
||||
int64 getPosition() override;
|
||||
bool setPosition (int64) override;
|
||||
|
||||
private:
|
||||
//==============================================================================
|
||||
const File file;
|
||||
void* fileHandle;
|
||||
int64 currentPosition;
|
||||
Result status;
|
||||
|
||||
void openHandle();
|
||||
size_t readInternal (void*, size_t);
|
||||
|
||||
JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (FileInputStream)
|
||||
};
|
||||
|
||||
|
||||
#endif // JUCE_FILEINPUTSTREAM_H_INCLUDED
|
||||
@@ -0,0 +1,134 @@
|
||||
/*
|
||||
==============================================================================
|
||||
|
||||
This file is part of the juce_core module of the JUCE library.
|
||||
Copyright (c) 2013 - Raw Material Software Ltd.
|
||||
|
||||
Permission to use, copy, modify, and/or distribute this software for any purpose with
|
||||
or without fee is hereby granted, provided that the above copyright notice and this
|
||||
permission notice appear in all copies.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
|
||||
TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN
|
||||
NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
|
||||
DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
|
||||
IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
|
||||
CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
|
||||
NOTE! This permissive ISC license applies ONLY to files within the juce_core module!
|
||||
All other JUCE modules are covered by a dual GPL/commercial license, so if you are
|
||||
using any other modules, be sure to check that you also comply with their license.
|
||||
|
||||
For more details, visit www.juce.com
|
||||
|
||||
==============================================================================
|
||||
*/
|
||||
|
||||
int64 juce_fileSetPosition (void* handle, int64 pos);
|
||||
|
||||
//==============================================================================
|
||||
FileOutputStream::FileOutputStream (const File& f, const size_t bufferSizeToUse)
|
||||
: file (f),
|
||||
fileHandle (nullptr),
|
||||
status (Result::ok()),
|
||||
currentPosition (0),
|
||||
bufferSize (bufferSizeToUse),
|
||||
bytesInBuffer (0),
|
||||
buffer (jmax (bufferSizeToUse, (size_t) 16))
|
||||
{
|
||||
openHandle();
|
||||
}
|
||||
|
||||
FileOutputStream::~FileOutputStream()
|
||||
{
|
||||
flushBuffer();
|
||||
closeHandle();
|
||||
}
|
||||
|
||||
int64 FileOutputStream::getPosition()
|
||||
{
|
||||
return currentPosition;
|
||||
}
|
||||
|
||||
bool FileOutputStream::setPosition (int64 newPosition)
|
||||
{
|
||||
if (newPosition != currentPosition)
|
||||
{
|
||||
flushBuffer();
|
||||
currentPosition = juce_fileSetPosition (fileHandle, newPosition);
|
||||
}
|
||||
|
||||
return newPosition == currentPosition;
|
||||
}
|
||||
|
||||
bool FileOutputStream::flushBuffer()
|
||||
{
|
||||
bool ok = true;
|
||||
|
||||
if (bytesInBuffer > 0)
|
||||
{
|
||||
ok = (writeInternal (buffer, bytesInBuffer) == (ssize_t) bytesInBuffer);
|
||||
bytesInBuffer = 0;
|
||||
}
|
||||
|
||||
return ok;
|
||||
}
|
||||
|
||||
void FileOutputStream::flush()
|
||||
{
|
||||
flushBuffer();
|
||||
flushInternal();
|
||||
}
|
||||
|
||||
bool FileOutputStream::write (const void* const src, const size_t numBytes)
|
||||
{
|
||||
jassert (src != nullptr && ((ssize_t) numBytes) >= 0);
|
||||
|
||||
if (bytesInBuffer + numBytes < bufferSize)
|
||||
{
|
||||
memcpy (buffer + bytesInBuffer, src, numBytes);
|
||||
bytesInBuffer += numBytes;
|
||||
currentPosition += numBytes;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (! flushBuffer())
|
||||
return false;
|
||||
|
||||
if (numBytes < bufferSize)
|
||||
{
|
||||
memcpy (buffer + bytesInBuffer, src, numBytes);
|
||||
bytesInBuffer += numBytes;
|
||||
currentPosition += numBytes;
|
||||
}
|
||||
else
|
||||
{
|
||||
const ssize_t bytesWritten = writeInternal (src, numBytes);
|
||||
|
||||
if (bytesWritten < 0)
|
||||
return false;
|
||||
|
||||
currentPosition += bytesWritten;
|
||||
return bytesWritten == (ssize_t) numBytes;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool FileOutputStream::writeRepeatedByte (uint8 byte, size_t numBytes)
|
||||
{
|
||||
jassert (((ssize_t) numBytes) >= 0);
|
||||
|
||||
if (bytesInBuffer + numBytes < bufferSize)
|
||||
{
|
||||
memset (buffer + bytesInBuffer, byte, numBytes);
|
||||
bytesInBuffer += numBytes;
|
||||
currentPosition += numBytes;
|
||||
return true;
|
||||
}
|
||||
|
||||
return OutputStream::writeRepeatedByte (byte, numBytes);
|
||||
}
|
||||
@@ -0,0 +1,116 @@
|
||||
/*
|
||||
==============================================================================
|
||||
|
||||
This file is part of the juce_core module of the JUCE library.
|
||||
Copyright (c) 2013 - Raw Material Software Ltd.
|
||||
|
||||
Permission to use, copy, modify, and/or distribute this software for any purpose with
|
||||
or without fee is hereby granted, provided that the above copyright notice and this
|
||||
permission notice appear in all copies.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
|
||||
TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN
|
||||
NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
|
||||
DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
|
||||
IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
|
||||
CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
|
||||
NOTE! This permissive ISC license applies ONLY to files within the juce_core module!
|
||||
All other JUCE modules are covered by a dual GPL/commercial license, so if you are
|
||||
using any other modules, be sure to check that you also comply with their license.
|
||||
|
||||
For more details, visit www.juce.com
|
||||
|
||||
==============================================================================
|
||||
*/
|
||||
|
||||
#ifndef JUCE_FILEOUTPUTSTREAM_H_INCLUDED
|
||||
#define JUCE_FILEOUTPUTSTREAM_H_INCLUDED
|
||||
|
||||
|
||||
//==============================================================================
|
||||
/**
|
||||
An output stream that writes into a local file.
|
||||
|
||||
@see OutputStream, FileInputStream, File::createOutputStream
|
||||
*/
|
||||
class JUCE_API FileOutputStream : public OutputStream
|
||||
{
|
||||
public:
|
||||
//==============================================================================
|
||||
/** Creates a FileOutputStream.
|
||||
|
||||
If the file doesn't exist, it will first be created. If the file can't be
|
||||
created or opened, the failedToOpen() method will return
|
||||
true.
|
||||
|
||||
If the file already exists when opened, the stream's write-postion will
|
||||
be set to the end of the file. To overwrite an existing file,
|
||||
use File::deleteFile() before opening the stream, or use setPosition(0)
|
||||
after it's opened (although this won't truncate the file).
|
||||
|
||||
@see TemporaryFile
|
||||
*/
|
||||
FileOutputStream (const File& fileToWriteTo,
|
||||
size_t bufferSizeToUse = 16384);
|
||||
|
||||
/** Destructor. */
|
||||
~FileOutputStream();
|
||||
|
||||
//==============================================================================
|
||||
/** Returns the file that this stream is writing to.
|
||||
*/
|
||||
const File& getFile() const { return file; }
|
||||
|
||||
/** Returns the status of the file stream.
|
||||
The result will be ok if the file opened successfully. If an error occurs while
|
||||
opening or writing to the file, this will contain an error message.
|
||||
*/
|
||||
const Result& getStatus() const noexcept { return status; }
|
||||
|
||||
/** Returns true if the stream couldn't be opened for some reason.
|
||||
@see getResult()
|
||||
*/
|
||||
bool failedToOpen() const noexcept { return status.failed(); }
|
||||
|
||||
/** Returns true if the stream opened without problems.
|
||||
@see getResult()
|
||||
*/
|
||||
bool openedOk() const noexcept { return status.wasOk(); }
|
||||
|
||||
/** Attempts to truncate the file to the current write position.
|
||||
To truncate a file to a specific size, first use setPosition() to seek to the
|
||||
appropriate location, and then call this method.
|
||||
*/
|
||||
Result truncate();
|
||||
|
||||
//==============================================================================
|
||||
void flush() override;
|
||||
int64 getPosition() override;
|
||||
bool setPosition (int64) override;
|
||||
bool write (const void*, size_t) override;
|
||||
bool writeRepeatedByte (uint8 byte, size_t numTimesToRepeat) override;
|
||||
|
||||
|
||||
private:
|
||||
//==============================================================================
|
||||
File file;
|
||||
void* fileHandle;
|
||||
Result status;
|
||||
int64 currentPosition;
|
||||
size_t bufferSize, bytesInBuffer;
|
||||
HeapBlock <char> buffer;
|
||||
|
||||
void openHandle();
|
||||
void closeHandle();
|
||||
void flushInternal();
|
||||
bool flushBuffer();
|
||||
int64 setPositionInternal (int64);
|
||||
ssize_t writeInternal (const void*, size_t);
|
||||
|
||||
JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (FileOutputStream)
|
||||
};
|
||||
|
||||
#endif // JUCE_FILEOUTPUTSTREAM_H_INCLUDED
|
||||
@@ -0,0 +1,172 @@
|
||||
/*
|
||||
==============================================================================
|
||||
|
||||
This file is part of the juce_core module of the JUCE library.
|
||||
Copyright (c) 2013 - Raw Material Software Ltd.
|
||||
|
||||
Permission to use, copy, modify, and/or distribute this software for any purpose with
|
||||
or without fee is hereby granted, provided that the above copyright notice and this
|
||||
permission notice appear in all copies.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
|
||||
TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN
|
||||
NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
|
||||
DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
|
||||
IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
|
||||
CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
|
||||
NOTE! This permissive ISC license applies ONLY to files within the juce_core module!
|
||||
All other JUCE modules are covered by a dual GPL/commercial license, so if you are
|
||||
using any other modules, be sure to check that you also comply with their license.
|
||||
|
||||
For more details, visit www.juce.com
|
||||
|
||||
==============================================================================
|
||||
*/
|
||||
|
||||
FileSearchPath::FileSearchPath() {}
|
||||
FileSearchPath::~FileSearchPath() {}
|
||||
|
||||
FileSearchPath::FileSearchPath (const String& path)
|
||||
{
|
||||
init (path);
|
||||
}
|
||||
|
||||
FileSearchPath::FileSearchPath (const FileSearchPath& other)
|
||||
: directories (other.directories)
|
||||
{
|
||||
}
|
||||
|
||||
FileSearchPath& FileSearchPath::operator= (const FileSearchPath& other)
|
||||
{
|
||||
directories = other.directories;
|
||||
return *this;
|
||||
}
|
||||
|
||||
FileSearchPath& FileSearchPath::operator= (const String& path)
|
||||
{
|
||||
init (path);
|
||||
return *this;
|
||||
}
|
||||
|
||||
void FileSearchPath::init (const String& path)
|
||||
{
|
||||
directories.clear();
|
||||
directories.addTokens (path, ";", "\"");
|
||||
directories.trim();
|
||||
directories.removeEmptyStrings();
|
||||
|
||||
for (int i = directories.size(); --i >= 0;)
|
||||
directories.set (i, directories[i].unquoted());
|
||||
}
|
||||
|
||||
int FileSearchPath::getNumPaths() const
|
||||
{
|
||||
return directories.size();
|
||||
}
|
||||
|
||||
File FileSearchPath::operator[] (const int index) const
|
||||
{
|
||||
return File (directories [index]);
|
||||
}
|
||||
|
||||
String FileSearchPath::toString() const
|
||||
{
|
||||
StringArray directories2 (directories);
|
||||
for (int i = directories2.size(); --i >= 0;)
|
||||
if (directories2[i].containsChar (';'))
|
||||
directories2.set (i, directories2[i].quoted());
|
||||
|
||||
return directories2.joinIntoString (";");
|
||||
}
|
||||
|
||||
void FileSearchPath::add (const File& dir, const int insertIndex)
|
||||
{
|
||||
directories.insert (insertIndex, dir.getFullPathName());
|
||||
}
|
||||
|
||||
void FileSearchPath::addIfNotAlreadyThere (const File& dir)
|
||||
{
|
||||
for (int i = 0; i < directories.size(); ++i)
|
||||
if (File (directories[i]) == dir)
|
||||
return;
|
||||
|
||||
add (dir);
|
||||
}
|
||||
|
||||
void FileSearchPath::remove (const int index)
|
||||
{
|
||||
directories.remove (index);
|
||||
}
|
||||
|
||||
void FileSearchPath::addPath (const FileSearchPath& other)
|
||||
{
|
||||
for (int i = 0; i < other.getNumPaths(); ++i)
|
||||
addIfNotAlreadyThere (other[i]);
|
||||
}
|
||||
|
||||
void FileSearchPath::removeRedundantPaths()
|
||||
{
|
||||
for (int i = directories.size(); --i >= 0;)
|
||||
{
|
||||
const File d1 (directories[i]);
|
||||
|
||||
for (int j = directories.size(); --j >= 0;)
|
||||
{
|
||||
const File d2 (directories[j]);
|
||||
|
||||
if ((i != j) && (d1.isAChildOf (d2) || d1 == d2))
|
||||
{
|
||||
directories.remove (i);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void FileSearchPath::removeNonExistentPaths()
|
||||
{
|
||||
for (int i = directories.size(); --i >= 0;)
|
||||
if (! File (directories[i]).isDirectory())
|
||||
directories.remove (i);
|
||||
}
|
||||
|
||||
int FileSearchPath::findChildFiles (Array<File>& results,
|
||||
const int whatToLookFor,
|
||||
const bool searchRecursively,
|
||||
const String& wildCardPattern) const
|
||||
{
|
||||
int total = 0;
|
||||
|
||||
for (int i = 0; i < directories.size(); ++i)
|
||||
total += operator[] (i).findChildFiles (results,
|
||||
whatToLookFor,
|
||||
searchRecursively,
|
||||
wildCardPattern);
|
||||
|
||||
return total;
|
||||
}
|
||||
|
||||
bool FileSearchPath::isFileInPath (const File& fileToCheck,
|
||||
const bool checkRecursively) const
|
||||
{
|
||||
for (int i = directories.size(); --i >= 0;)
|
||||
{
|
||||
const File d (directories[i]);
|
||||
|
||||
if (checkRecursively)
|
||||
{
|
||||
if (fileToCheck.isAChildOf (d))
|
||||
return true;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (fileToCheck.getParentDirectory() == d)
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
@@ -0,0 +1,165 @@
|
||||
/*
|
||||
==============================================================================
|
||||
|
||||
This file is part of the juce_core module of the JUCE library.
|
||||
Copyright (c) 2013 - Raw Material Software Ltd.
|
||||
|
||||
Permission to use, copy, modify, and/or distribute this software for any purpose with
|
||||
or without fee is hereby granted, provided that the above copyright notice and this
|
||||
permission notice appear in all copies.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
|
||||
TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN
|
||||
NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
|
||||
DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
|
||||
IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
|
||||
CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
|
||||
NOTE! This permissive ISC license applies ONLY to files within the juce_core module!
|
||||
All other JUCE modules are covered by a dual GPL/commercial license, so if you are
|
||||
using any other modules, be sure to check that you also comply with their license.
|
||||
|
||||
For more details, visit www.juce.com
|
||||
|
||||
==============================================================================
|
||||
*/
|
||||
|
||||
#ifndef JUCE_FILESEARCHPATH_H_INCLUDED
|
||||
#define JUCE_FILESEARCHPATH_H_INCLUDED
|
||||
|
||||
|
||||
//==============================================================================
|
||||
/**
|
||||
Represents a set of folders that make up a search path.
|
||||
|
||||
@see File
|
||||
*/
|
||||
class JUCE_API FileSearchPath
|
||||
{
|
||||
public:
|
||||
//==============================================================================
|
||||
/** Creates an empty search path. */
|
||||
FileSearchPath();
|
||||
|
||||
/** Creates a search path from a string of pathnames.
|
||||
|
||||
The path can be semicolon- or comma-separated, e.g.
|
||||
"/foo/bar;/foo/moose;/fish/moose"
|
||||
|
||||
The separate folders are tokenised and added to the search path.
|
||||
*/
|
||||
FileSearchPath (const String& path);
|
||||
|
||||
/** Creates a copy of another search path. */
|
||||
FileSearchPath (const FileSearchPath&);
|
||||
|
||||
/** Copies another search path. */
|
||||
FileSearchPath& operator= (const FileSearchPath&);
|
||||
|
||||
/** Destructor. */
|
||||
~FileSearchPath();
|
||||
|
||||
/** Uses a string containing a list of pathnames to re-initialise this list.
|
||||
|
||||
This search path is cleared and the semicolon- or comma-separated folders
|
||||
in this string are added instead. e.g. "/foo/bar;/foo/moose;/fish/moose"
|
||||
*/
|
||||
FileSearchPath& operator= (const String& path);
|
||||
|
||||
//==============================================================================
|
||||
/** Returns the number of folders in this search path.
|
||||
@see operator[]
|
||||
*/
|
||||
int getNumPaths() const;
|
||||
|
||||
/** Returns one of the folders in this search path.
|
||||
The file returned isn't guaranteed to actually be a valid directory.
|
||||
@see getNumPaths
|
||||
*/
|
||||
File operator[] (int index) const;
|
||||
|
||||
/** Returns the search path as a semicolon-separated list of directories. */
|
||||
String toString() const;
|
||||
|
||||
//==============================================================================
|
||||
/** Adds a new directory to the search path.
|
||||
|
||||
The new directory is added to the end of the list if the insertIndex parameter is
|
||||
less than zero, otherwise it is inserted at the given index.
|
||||
*/
|
||||
void add (const File& directoryToAdd,
|
||||
int insertIndex = -1);
|
||||
|
||||
/** Adds a new directory to the search path if it's not already in there. */
|
||||
void addIfNotAlreadyThere (const File& directoryToAdd);
|
||||
|
||||
/** Removes a directory from the search path. */
|
||||
void remove (int indexToRemove);
|
||||
|
||||
/** Merges another search path into this one.
|
||||
This will remove any duplicate directories.
|
||||
*/
|
||||
void addPath (const FileSearchPath&);
|
||||
|
||||
/** Removes any directories that are actually subdirectories of one of the other directories in the search path.
|
||||
|
||||
If the search is intended to be recursive, there's no point having nested folders in the search
|
||||
path, because they'll just get searched twice and you'll get duplicate results.
|
||||
|
||||
e.g. if the path is "c:\abc\de;c:\abc", this method will simplify it to "c:\abc"
|
||||
*/
|
||||
void removeRedundantPaths();
|
||||
|
||||
/** Removes any directories that don't actually exist. */
|
||||
void removeNonExistentPaths();
|
||||
|
||||
//==============================================================================
|
||||
/** Searches the path for a wildcard.
|
||||
|
||||
This will search all the directories in the search path in order, adding any
|
||||
matching files to the results array.
|
||||
|
||||
@param results an array to append the results to
|
||||
@param whatToLookFor a value from the File::TypesOfFileToFind enum, specifying whether to
|
||||
return files, directories, or both.
|
||||
@param searchRecursively whether to recursively search the subdirectories too
|
||||
@param wildCardPattern a pattern to match against the filenames
|
||||
@returns the number of files added to the array
|
||||
@see File::findChildFiles
|
||||
*/
|
||||
int findChildFiles (Array<File>& results,
|
||||
int whatToLookFor,
|
||||
bool searchRecursively,
|
||||
const String& wildCardPattern = "*") const;
|
||||
|
||||
//==============================================================================
|
||||
/** Finds out whether a file is inside one of the path's directories.
|
||||
|
||||
This will return true if the specified file is a child of one of the
|
||||
directories specified by this path. Note that this doesn't actually do any
|
||||
searching or check that the files exist - it just looks at the pathnames
|
||||
to work out whether the file would be inside a directory.
|
||||
|
||||
@param fileToCheck the file to look for
|
||||
@param checkRecursively if true, then this will return true if the file is inside a
|
||||
subfolder of one of the path's directories (at any depth). If false
|
||||
it will only return true if the file is actually a direct child
|
||||
of one of the directories.
|
||||
@see File::isAChildOf
|
||||
|
||||
*/
|
||||
bool isFileInPath (const File& fileToCheck,
|
||||
bool checkRecursively) const;
|
||||
|
||||
private:
|
||||
//==============================================================================
|
||||
StringArray directories;
|
||||
|
||||
void init (const String&);
|
||||
|
||||
JUCE_LEAK_DETECTOR (FileSearchPath)
|
||||
};
|
||||
|
||||
#endif // JUCE_FILESEARCHPATH_H_INCLUDED
|
||||
@@ -0,0 +1,115 @@
|
||||
/*
|
||||
==============================================================================
|
||||
|
||||
This file is part of the juce_core module of the JUCE library.
|
||||
Copyright (c) 2013 - Raw Material Software Ltd.
|
||||
|
||||
Permission to use, copy, modify, and/or distribute this software for any purpose with
|
||||
or without fee is hereby granted, provided that the above copyright notice and this
|
||||
permission notice appear in all copies.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
|
||||
TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN
|
||||
NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
|
||||
DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
|
||||
IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
|
||||
CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
|
||||
NOTE! This permissive ISC license applies ONLY to files within the juce_core module!
|
||||
All other JUCE modules are covered by a dual GPL/commercial license, so if you are
|
||||
using any other modules, be sure to check that you also comply with their license.
|
||||
|
||||
For more details, visit www.juce.com
|
||||
|
||||
==============================================================================
|
||||
*/
|
||||
|
||||
#ifndef JUCE_MEMORYMAPPEDFILE_H_INCLUDED
|
||||
#define JUCE_MEMORYMAPPEDFILE_H_INCLUDED
|
||||
|
||||
|
||||
//==============================================================================
|
||||
/**
|
||||
Maps a file into virtual memory for easy reading and/or writing.
|
||||
*/
|
||||
class JUCE_API MemoryMappedFile
|
||||
{
|
||||
public:
|
||||
/** The read/write flags used when opening a memory mapped file. */
|
||||
enum AccessMode
|
||||
{
|
||||
readOnly, /**< Indicates that the memory can only be read. */
|
||||
readWrite /**< Indicates that the memory can be read and written to - changes that are
|
||||
made will be flushed back to disk at the whim of the OS. */
|
||||
};
|
||||
|
||||
/** Opens a file and maps it to an area of virtual memory.
|
||||
|
||||
The file should already exist, and should already be the size that you want to work with
|
||||
when you call this. If the file is resized after being opened, the behaviour is undefined.
|
||||
|
||||
If the file exists and the operation succeeds, the getData() and getSize() methods will
|
||||
return the location and size of the data that can be read or written. Note that the entire
|
||||
file is not read into memory immediately - the OS simply creates a virtual mapping, which
|
||||
will lazily pull the data into memory when blocks are accessed.
|
||||
|
||||
If the file can't be opened for some reason, the getData() method will return a null pointer.
|
||||
*/
|
||||
MemoryMappedFile (const File& file, AccessMode mode);
|
||||
|
||||
/** Opens a section of a file and maps it to an area of virtual memory.
|
||||
|
||||
The file should already exist, and should already be the size that you want to work with
|
||||
when you call this. If the file is resized after being opened, the behaviour is undefined.
|
||||
|
||||
If the file exists and the operation succeeds, the getData() and getSize() methods will
|
||||
return the location and size of the data that can be read or written. Note that the entire
|
||||
file is not read into memory immediately - the OS simply creates a virtual mapping, which
|
||||
will lazily pull the data into memory when blocks are accessed.
|
||||
|
||||
If the file can't be opened for some reason, the getData() method will return a null pointer.
|
||||
|
||||
NOTE: the start of the actual range used may be rounded-down to a multiple of the OS's page-size,
|
||||
so do not assume that the mapped memory will begin at exactly the position you requested - always
|
||||
use getRange() to check the actual range that is being used.
|
||||
*/
|
||||
MemoryMappedFile (const File& file,
|
||||
const Range<int64>& fileRange,
|
||||
AccessMode mode);
|
||||
|
||||
/** Destructor. */
|
||||
~MemoryMappedFile();
|
||||
|
||||
/** Returns the address at which this file has been mapped, or a null pointer if
|
||||
the file couldn't be successfully mapped.
|
||||
*/
|
||||
void* getData() const noexcept { return address; }
|
||||
|
||||
/** Returns the number of bytes of data that are available for reading or writing.
|
||||
This will normally be the size of the file.
|
||||
*/
|
||||
size_t getSize() const noexcept { return (size_t) range.getLength(); }
|
||||
|
||||
/** Returns the section of the file at which the mapped memory represents. */
|
||||
Range<int64> getRange() const noexcept { return range; }
|
||||
|
||||
private:
|
||||
//==============================================================================
|
||||
void* address;
|
||||
Range<int64> range;
|
||||
|
||||
#if JUCE_WINDOWS
|
||||
void* fileHandle;
|
||||
#else
|
||||
int fileHandle;
|
||||
#endif
|
||||
|
||||
void openInternal (const File&, AccessMode);
|
||||
|
||||
JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (MemoryMappedFile)
|
||||
};
|
||||
|
||||
|
||||
#endif // JUCE_MEMORYMAPPEDFILE_H_INCLUDED
|
||||
@@ -0,0 +1,117 @@
|
||||
/*
|
||||
==============================================================================
|
||||
|
||||
This file is part of the juce_core module of the JUCE library.
|
||||
Copyright (c) 2013 - Raw Material Software Ltd.
|
||||
|
||||
Permission to use, copy, modify, and/or distribute this software for any purpose with
|
||||
or without fee is hereby granted, provided that the above copyright notice and this
|
||||
permission notice appear in all copies.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
|
||||
TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN
|
||||
NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
|
||||
DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
|
||||
IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
|
||||
CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
|
||||
NOTE! This permissive ISC license applies ONLY to files within the juce_core module!
|
||||
All other JUCE modules are covered by a dual GPL/commercial license, so if you are
|
||||
using any other modules, be sure to check that you also comply with their license.
|
||||
|
||||
For more details, visit www.juce.com
|
||||
|
||||
==============================================================================
|
||||
*/
|
||||
|
||||
static File createTempFile (const File& parentDirectory, String name,
|
||||
const String& suffix, const int optionFlags)
|
||||
{
|
||||
if ((optionFlags & TemporaryFile::useHiddenFile) != 0)
|
||||
name = "." + name;
|
||||
|
||||
return parentDirectory.getNonexistentChildFile (name, suffix, (optionFlags & TemporaryFile::putNumbersInBrackets) != 0);
|
||||
}
|
||||
|
||||
TemporaryFile::TemporaryFile (const String& suffix, const int optionFlags)
|
||||
: temporaryFile (createTempFile (File::getSpecialLocation (File::tempDirectory),
|
||||
"temp_" + String::toHexString (Random::getSystemRandom().nextInt()),
|
||||
suffix, optionFlags))
|
||||
{
|
||||
}
|
||||
|
||||
TemporaryFile::TemporaryFile (const File& target, const int optionFlags)
|
||||
: temporaryFile (createTempFile (target.getParentDirectory(),
|
||||
target.getFileNameWithoutExtension()
|
||||
+ "_temp" + String::toHexString (Random::getSystemRandom().nextInt()),
|
||||
target.getFileExtension(), optionFlags)),
|
||||
targetFile (target)
|
||||
{
|
||||
// If you use this constructor, you need to give it a valid target file!
|
||||
jassert (targetFile != File());
|
||||
}
|
||||
|
||||
TemporaryFile::TemporaryFile (const File& target, const File& temporary)
|
||||
: temporaryFile (temporary), targetFile (target)
|
||||
{
|
||||
}
|
||||
|
||||
TemporaryFile::~TemporaryFile()
|
||||
{
|
||||
if (! deleteTemporaryFile())
|
||||
{
|
||||
/* Failed to delete our temporary file! The most likely reason for this would be
|
||||
that you've not closed an output stream that was being used to write to file.
|
||||
|
||||
If you find that something beyond your control is changing permissions on
|
||||
your temporary files and preventing them from being deleted, you may want to
|
||||
call TemporaryFile::deleteTemporaryFile() to detect those error cases and
|
||||
handle them appropriately.
|
||||
*/
|
||||
jassertfalse;
|
||||
}
|
||||
}
|
||||
|
||||
//==============================================================================
|
||||
bool TemporaryFile::overwriteTargetFileWithTemporary() const
|
||||
{
|
||||
// This method only works if you created this object with the constructor
|
||||
// that takes a target file!
|
||||
jassert (targetFile != File());
|
||||
|
||||
if (temporaryFile.exists())
|
||||
{
|
||||
// Have a few attempts at overwriting the file before giving up..
|
||||
for (int i = 5; --i >= 0;)
|
||||
{
|
||||
if (temporaryFile.moveFileTo (targetFile))
|
||||
return true;
|
||||
|
||||
Thread::sleep (100);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// There's no temporary file to use. If your write failed, you should
|
||||
// probably check, and not bother calling this method.
|
||||
jassertfalse;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
bool TemporaryFile::deleteTemporaryFile() const
|
||||
{
|
||||
// Have a few attempts at deleting the file before giving up..
|
||||
for (int i = 5; --i >= 0;)
|
||||
{
|
||||
if (temporaryFile.deleteFile())
|
||||
return true;
|
||||
|
||||
Thread::sleep (50);
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
@@ -0,0 +1,169 @@
|
||||
/*
|
||||
==============================================================================
|
||||
|
||||
This file is part of the juce_core module of the JUCE library.
|
||||
Copyright (c) 2013 - Raw Material Software Ltd.
|
||||
|
||||
Permission to use, copy, modify, and/or distribute this software for any purpose with
|
||||
or without fee is hereby granted, provided that the above copyright notice and this
|
||||
permission notice appear in all copies.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
|
||||
TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN
|
||||
NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
|
||||
DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
|
||||
IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
|
||||
CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
|
||||
NOTE! This permissive ISC license applies ONLY to files within the juce_core module!
|
||||
All other JUCE modules are covered by a dual GPL/commercial license, so if you are
|
||||
using any other modules, be sure to check that you also comply with their license.
|
||||
|
||||
For more details, visit www.juce.com
|
||||
|
||||
==============================================================================
|
||||
*/
|
||||
|
||||
#ifndef JUCE_TEMPORARYFILE_H_INCLUDED
|
||||
#define JUCE_TEMPORARYFILE_H_INCLUDED
|
||||
|
||||
|
||||
//==============================================================================
|
||||
/**
|
||||
Manages a temporary file, which will be deleted when this object is deleted.
|
||||
|
||||
This object is intended to be used as a stack based object, using its scope
|
||||
to make sure the temporary file isn't left lying around.
|
||||
|
||||
For example:
|
||||
|
||||
@code
|
||||
{
|
||||
File myTargetFile ("~/myfile.txt");
|
||||
|
||||
// this will choose a file called something like "~/myfile_temp239348.txt"
|
||||
// which definitely doesn't exist at the time the constructor is called.
|
||||
TemporaryFile temp (myTargetFile);
|
||||
|
||||
// create a stream to the temporary file, and write some data to it...
|
||||
ScopedPointer <FileOutputStream> out (temp.getFile().createOutputStream());
|
||||
|
||||
if (out != nullptr)
|
||||
{
|
||||
out->write ( ...etc )
|
||||
out = nullptr; // (deletes the stream)
|
||||
|
||||
// ..now we've finished writing, this will rename the temp file to
|
||||
// make it replace the target file we specified above.
|
||||
bool succeeded = temp.overwriteTargetFileWithTemporary();
|
||||
}
|
||||
|
||||
// ..and even if something went wrong and our overwrite failed,
|
||||
// as the TemporaryFile object goes out of scope here, it'll make sure
|
||||
// that the temp file gets deleted.
|
||||
}
|
||||
@endcode
|
||||
|
||||
@see File, FileOutputStream
|
||||
*/
|
||||
class JUCE_API TemporaryFile
|
||||
{
|
||||
public:
|
||||
//==============================================================================
|
||||
enum OptionFlags
|
||||
{
|
||||
useHiddenFile = 1, /**< Indicates that the temporary file should be hidden -
|
||||
i.e. its name should start with a dot. */
|
||||
putNumbersInBrackets = 2 /**< Indicates that when numbers are appended to make sure
|
||||
the file is unique, they should go in brackets rather
|
||||
than just being appended (see File::getNonexistentSibling() )*/
|
||||
};
|
||||
|
||||
//==============================================================================
|
||||
/** Creates a randomly-named temporary file in the default temp directory.
|
||||
|
||||
@param suffix a file suffix to use for the file
|
||||
@param optionFlags a combination of the values listed in the OptionFlags enum
|
||||
The file will not be created until you write to it. And remember that when
|
||||
this object is deleted, the file will also be deleted!
|
||||
*/
|
||||
TemporaryFile (const String& suffix = String(),
|
||||
int optionFlags = 0);
|
||||
|
||||
/** Creates a temporary file in the same directory as a specified file.
|
||||
|
||||
This is useful if you have a file that you want to overwrite, but don't
|
||||
want to harm the original file if the write operation fails. You can
|
||||
use this to create a temporary file next to the target file, then
|
||||
write to the temporary file, and finally use overwriteTargetFileWithTemporary()
|
||||
to replace the target file with the one you've just written.
|
||||
|
||||
This class won't create any files until you actually write to them. And remember
|
||||
that when this object is deleted, the temporary file will also be deleted!
|
||||
|
||||
@param targetFile the file that you intend to overwrite - the temporary
|
||||
file will be created in the same directory as this
|
||||
@param optionFlags a combination of the values listed in the OptionFlags enum
|
||||
*/
|
||||
TemporaryFile (const File& targetFile,
|
||||
int optionFlags = 0);
|
||||
|
||||
/** Creates a temporary file using an explicit filename.
|
||||
The other constructors are a better choice than this one, unless for some reason
|
||||
you need to explicitly specify the temporary file you want to use.
|
||||
|
||||
@param targetFile the file that you intend to overwrite
|
||||
@param temporaryFile the temporary file to be used
|
||||
*/
|
||||
TemporaryFile (const File& targetFile,
|
||||
const File& temporaryFile);
|
||||
|
||||
/** Destructor.
|
||||
|
||||
When this object is deleted it will make sure that its temporary file is
|
||||
also deleted! If the operation fails, it'll throw an assertion in debug
|
||||
mode.
|
||||
*/
|
||||
~TemporaryFile();
|
||||
|
||||
//==============================================================================
|
||||
/** Returns the temporary file. */
|
||||
const File& getFile() const noexcept { return temporaryFile; }
|
||||
|
||||
/** Returns the target file that was specified in the constructor. */
|
||||
const File& getTargetFile() const noexcept { return targetFile; }
|
||||
|
||||
/** Tries to move the temporary file to overwrite the target file that was
|
||||
specified in the constructor.
|
||||
|
||||
If you used the constructor that specified a target file, this will attempt
|
||||
to replace that file with the temporary one.
|
||||
|
||||
Before calling this, make sure:
|
||||
- that you've actually written to the temporary file
|
||||
- that you've closed any open streams that you were using to write to it
|
||||
- and that you don't have any streams open to the target file, which would
|
||||
prevent it being overwritten
|
||||
|
||||
If the file move succeeds, this returns false, and the temporary file will
|
||||
have disappeared. If it fails, the temporary file will probably still exist,
|
||||
but will be deleted when this object is destroyed.
|
||||
*/
|
||||
bool overwriteTargetFileWithTemporary() const;
|
||||
|
||||
/** Attempts to delete the temporary file, if it exists.
|
||||
@returns true if the file is successfully deleted (or if it didn't exist).
|
||||
*/
|
||||
bool deleteTemporaryFile() const;
|
||||
|
||||
|
||||
private:
|
||||
//==============================================================================
|
||||
const File temporaryFile, targetFile;
|
||||
|
||||
JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (TemporaryFile)
|
||||
};
|
||||
|
||||
#endif // JUCE_TEMPORARYFILE_H_INCLUDED
|
||||
@@ -0,0 +1,76 @@
|
||||
/*
|
||||
==============================================================================
|
||||
|
||||
This file is part of the juce_core module of the JUCE library.
|
||||
Copyright (c) 2013 - Raw Material Software Ltd.
|
||||
|
||||
Permission to use, copy, modify, and/or distribute this software for any purpose with
|
||||
or without fee is hereby granted, provided that the above copyright notice and this
|
||||
permission notice appear in all copies.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
|
||||
TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN
|
||||
NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
|
||||
DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
|
||||
IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
|
||||
CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
|
||||
NOTE! This permissive ISC license applies ONLY to files within the juce_core module!
|
||||
All other JUCE modules are covered by a dual GPL/commercial license, so if you are
|
||||
using any other modules, be sure to check that you also comply with their license.
|
||||
|
||||
For more details, visit www.juce.com
|
||||
|
||||
==============================================================================
|
||||
*/
|
||||
|
||||
static void parseWildcard (const String& pattern, StringArray& result)
|
||||
{
|
||||
result.addTokens (pattern.toLowerCase(), ";,", "\"'");
|
||||
|
||||
result.trim();
|
||||
result.removeEmptyStrings();
|
||||
|
||||
// special case for *.*, because people use it to mean "any file", but it
|
||||
// would actually ignore files with no extension.
|
||||
for (int i = result.size(); --i >= 0;)
|
||||
if (result[i] == "*.*")
|
||||
result.set (i, "*");
|
||||
}
|
||||
|
||||
static bool matchWildcard (const File& file, const StringArray& wildcards)
|
||||
{
|
||||
const String filename (file.getFileName());
|
||||
|
||||
for (int i = wildcards.size(); --i >= 0;)
|
||||
if (filename.matchesWildcard (wildcards[i], true))
|
||||
return true;
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
WildcardFileFilter::WildcardFileFilter (const String& fileWildcardPatterns,
|
||||
const String& directoryWildcardPatterns,
|
||||
const String& desc)
|
||||
: FileFilter (desc.isEmpty() ? fileWildcardPatterns
|
||||
: (desc + " (" + fileWildcardPatterns + ")"))
|
||||
{
|
||||
parseWildcard (fileWildcardPatterns, fileWildcards);
|
||||
parseWildcard (directoryWildcardPatterns, directoryWildcards);
|
||||
}
|
||||
|
||||
WildcardFileFilter::~WildcardFileFilter()
|
||||
{
|
||||
}
|
||||
|
||||
bool WildcardFileFilter::isFileSuitable (const File& file) const
|
||||
{
|
||||
return matchWildcard (file, fileWildcards);
|
||||
}
|
||||
|
||||
bool WildcardFileFilter::isDirectorySuitable (const File& file) const
|
||||
{
|
||||
return matchWildcard (file, directoryWildcards);
|
||||
}
|
||||
@@ -0,0 +1,82 @@
|
||||
/*
|
||||
==============================================================================
|
||||
|
||||
This file is part of the juce_core module of the JUCE library.
|
||||
Copyright (c) 2013 - Raw Material Software Ltd.
|
||||
|
||||
Permission to use, copy, modify, and/or distribute this software for any purpose with
|
||||
or without fee is hereby granted, provided that the above copyright notice and this
|
||||
permission notice appear in all copies.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
|
||||
TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN
|
||||
NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
|
||||
DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
|
||||
IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
|
||||
CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
|
||||
NOTE! This permissive ISC license applies ONLY to files within the juce_core module!
|
||||
All other JUCE modules are covered by a dual GPL/commercial license, so if you are
|
||||
using any other modules, be sure to check that you also comply with their license.
|
||||
|
||||
For more details, visit www.juce.com
|
||||
|
||||
==============================================================================
|
||||
*/
|
||||
|
||||
#ifndef JUCE_WILDCARDFILEFILTER_H_INCLUDED
|
||||
#define JUCE_WILDCARDFILEFILTER_H_INCLUDED
|
||||
|
||||
|
||||
//==============================================================================
|
||||
/**
|
||||
A type of FileFilter that works by wildcard pattern matching.
|
||||
|
||||
This filter only allows files that match one of the specified patterns, but
|
||||
allows all directories through.
|
||||
|
||||
@see FileFilter, DirectoryContentsList, FileListComponent, FileBrowserComponent
|
||||
*/
|
||||
class JUCE_API WildcardFileFilter : public FileFilter
|
||||
{
|
||||
public:
|
||||
//==============================================================================
|
||||
/**
|
||||
Creates a wildcard filter for one or more patterns.
|
||||
|
||||
The wildcardPatterns parameter is a comma or semicolon-delimited set of
|
||||
patterns, e.g. "*.wav;*.aiff" would look for files ending in either .wav
|
||||
or .aiff.
|
||||
|
||||
Passing an empty string as a pattern will fail to match anything, so by leaving
|
||||
either the file or directory pattern parameter empty means you can control
|
||||
whether files or directories are found.
|
||||
|
||||
The description is a name to show the user in a list of possible patterns, so
|
||||
for the wav/aiff example, your description might be "audio files".
|
||||
*/
|
||||
WildcardFileFilter (const String& fileWildcardPatterns,
|
||||
const String& directoryWildcardPatterns,
|
||||
const String& description);
|
||||
|
||||
/** Destructor. */
|
||||
~WildcardFileFilter();
|
||||
|
||||
//==============================================================================
|
||||
/** Returns true if the filename matches one of the patterns specified. */
|
||||
bool isFileSuitable (const File& file) const;
|
||||
|
||||
/** This always returns true. */
|
||||
bool isDirectorySuitable (const File& file) const;
|
||||
|
||||
private:
|
||||
//==============================================================================
|
||||
StringArray fileWildcards, directoryWildcards;
|
||||
|
||||
JUCE_LEAK_DETECTOR (WildcardFileFilter)
|
||||
};
|
||||
|
||||
|
||||
#endif // JUCE_WILDCARDFILEFILTER_H_INCLUDED
|
||||
Reference in New Issue
Block a user