rhubarb-lip-sync/rhubarb/lib/webrtc-8d2248ff/webrtc/base/fileutils.h

437 lines
15 KiB
C++

/*
* Copyright 2004 The WebRTC Project Authors. All rights reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#ifndef WEBRTC_BASE_FILEUTILS_H_
#define WEBRTC_BASE_FILEUTILS_H_
#include <string>
#if !defined(WEBRTC_WIN)
#include <dirent.h>
#include <stdio.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#endif
#include "webrtc/base/basictypes.h"
#include "webrtc/base/common.h"
#include "webrtc/base/constructormagic.h"
#include "webrtc/base/platform_file.h"
namespace rtc {
class FileStream;
class Pathname;
//////////////////////////
// Directory Iterator //
//////////////////////////
// A DirectoryIterator is created with a given directory. It originally points
// to the first file in the directory, and can be advanecd with Next(). This
// allows you to get information about each file.
class DirectoryIterator {
friend class Filesystem;
public:
// Constructor
DirectoryIterator();
// Destructor
virtual ~DirectoryIterator();
// Starts traversing a directory
// dir is the directory to traverse
// returns true if the directory exists and is valid
// The iterator will point to the first entry in the directory
virtual bool Iterate(const Pathname &path);
// Advances to the next file
// returns true if there were more files in the directory.
virtual bool Next();
// returns true if the file currently pointed to is a directory
virtual bool IsDirectory() const;
// returns the name of the file currently pointed to
virtual std::string Name() const;
// returns the size of the file currently pointed to
virtual size_t FileSize() const;
// returns true if the file is older than seconds
virtual bool OlderThan(int seconds) const;
// checks whether current file is a special directory file "." or ".."
bool IsDots() const {
std::string filename(Name());
return (filename.compare(".") == 0) || (filename.compare("..") == 0);
}
private:
std::string directory_;
#if defined(WEBRTC_WIN)
WIN32_FIND_DATA data_;
HANDLE handle_;
#else
DIR *dir_;
struct dirent *dirent_;
struct stat stat_;
#endif
};
enum FileTimeType { FTT_CREATED, FTT_MODIFIED, FTT_ACCESSED };
class FilesystemInterface {
public:
virtual ~FilesystemInterface() {}
// Returns a DirectoryIterator for a given pathname.
// TODO: Do fancy abstracted stuff
virtual DirectoryIterator* IterateDirectory();
// Opens a file. Returns an open StreamInterface if function succeeds.
// Otherwise, returns NULL.
// TODO: Add an error param to indicate failure reason, similar to
// FileStream::Open
virtual FileStream *OpenFile(const Pathname &filename,
const std::string &mode) = 0;
// Atomically creates an empty file accessible only to the current user if one
// does not already exist at the given path, otherwise fails. This is the only
// secure way to create a file in a shared temp directory (e.g., C:\Temp on
// Windows or /tmp on Linux).
// Note that if it is essential that a file be successfully created then the
// app must generate random names and retry on failure, or else it will be
// vulnerable to a trivial DoS.
virtual bool CreatePrivateFile(const Pathname &filename) = 0;
// This will attempt to delete the path located at filename.
// It ASSERTS and returns false if the path points to a folder or a
// non-existent file.
virtual bool DeleteFile(const Pathname &filename) = 0;
// This will attempt to delete the empty folder located at 'folder'
// It ASSERTS and returns false if the path points to a file or a non-existent
// folder. It fails normally if the folder is not empty or can otherwise
// not be deleted.
virtual bool DeleteEmptyFolder(const Pathname &folder) = 0;
// This will call IterateDirectory, to get a directory iterator, and then
// call DeleteFolderAndContents and DeleteFile on every path contained in this
// folder. If the folder is empty, this returns true.
virtual bool DeleteFolderContents(const Pathname &folder);
// This deletes the contents of a folder, recursively, and then deletes
// the folder itself.
virtual bool DeleteFolderAndContents(const Pathname& folder);
// This will delete whatever is located at path, be it a file or a folder.
// If it is a folder, it will delete it recursively by calling
// DeleteFolderAndContents
bool DeleteFileOrFolder(const Pathname &path) {
if (IsFolder(path))
return DeleteFolderAndContents(path);
else
return DeleteFile(path);
}
// Creates a directory. This will call itself recursively to create /foo/bar
// even if /foo does not exist. Returns true if the function succeeds.
virtual bool CreateFolder(const Pathname &pathname) = 0;
// This moves a file from old_path to new_path, where "old_path" is a
// plain file. This ASSERTs and returns false if old_path points to a
// directory, and returns true if the function succeeds.
// If the new path is on a different volume than the old path, this function
// will attempt to copy and, if that succeeds, delete the old path.
virtual bool MoveFolder(const Pathname &old_path,
const Pathname &new_path) = 0;
// This moves a directory from old_path to new_path, where "old_path" is a
// directory. This ASSERTs and returns false if old_path points to a plain
// file, and returns true if the function succeeds.
// If the new path is on a different volume, this function will attempt to
// copy and if that succeeds, delete the old path.
virtual bool MoveFile(const Pathname &old_path, const Pathname &new_path) = 0;
// This attempts to move whatever is located at old_path to new_path,
// be it a file or folder.
bool MoveFileOrFolder(const Pathname &old_path, const Pathname &new_path) {
if (IsFile(old_path)) {
return MoveFile(old_path, new_path);
} else {
return MoveFolder(old_path, new_path);
}
}
// This copies a file from old_path to new_path. This method ASSERTs and
// returns false if old_path is a folder, and returns true if the copy
// succeeds.
virtual bool CopyFile(const Pathname &old_path, const Pathname &new_path) = 0;
// This copies a folder from old_path to new_path.
bool CopyFolder(const Pathname &old_path, const Pathname &new_path);
bool CopyFileOrFolder(const Pathname &old_path, const Pathname &new_path) {
if (IsFile(old_path))
return CopyFile(old_path, new_path);
else
return CopyFolder(old_path, new_path);
}
// Returns true if pathname refers to a directory
virtual bool IsFolder(const Pathname& pathname) = 0;
// Returns true if pathname refers to a file
virtual bool IsFile(const Pathname& pathname) = 0;
// Returns true if pathname refers to no filesystem object, every parent
// directory either exists, or is also absent.
virtual bool IsAbsent(const Pathname& pathname) = 0;
// Returns true if pathname represents a temporary location on the system.
virtual bool IsTemporaryPath(const Pathname& pathname) = 0;
// A folder appropriate for storing temporary files (Contents are
// automatically deleted when the program exits)
virtual bool GetTemporaryFolder(Pathname &path, bool create,
const std::string *append) = 0;
virtual std::string TempFilename(const Pathname &dir,
const std::string &prefix) = 0;
// Determines the size of the file indicated by path.
virtual bool GetFileSize(const Pathname& path, size_t* size) = 0;
// Determines a timestamp associated with the file indicated by path.
virtual bool GetFileTime(const Pathname& path, FileTimeType which,
time_t* time) = 0;
// Returns the path to the running application.
// Note: This is not guaranteed to work on all platforms. Be aware of the
// limitations before using it, and robustly handle failure.
virtual bool GetAppPathname(Pathname* path) = 0;
// Get a folder that is unique to the current application, which is suitable
// for sharing data between executions of the app. If the per_user arg is
// true, the folder is also specific to the current user.
virtual bool GetAppDataFolder(Pathname* path, bool per_user) = 0;
// Get a temporary folder that is unique to the current user and application.
// TODO: Re-evaluate the goals of this function. We probably just need any
// directory that won't collide with another existing directory, and which
// will be cleaned up when the program exits.
virtual bool GetAppTempFolder(Pathname* path) = 0;
// Delete the contents of the folder returned by GetAppTempFolder
bool CleanAppTempFolder();
virtual bool GetDiskFreeSpace(const Pathname& path, int64_t* freebytes) = 0;
// Returns the absolute path of the current directory.
virtual Pathname GetCurrentDirectory() = 0;
// Note: These might go into some shared config section later, but they're
// used by some methods in this interface, so we're leaving them here for now.
void SetOrganizationName(const std::string& organization) {
organization_name_ = organization;
}
void GetOrganizationName(std::string* organization) {
ASSERT(NULL != organization);
*organization = organization_name_;
}
void SetApplicationName(const std::string& application) {
application_name_ = application;
}
void GetApplicationName(std::string* application) {
ASSERT(NULL != application);
*application = application_name_;
}
protected:
std::string organization_name_;
std::string application_name_;
};
class Filesystem {
public:
static FilesystemInterface *default_filesystem() {
ASSERT(default_filesystem_ != NULL);
return default_filesystem_;
}
static void set_default_filesystem(FilesystemInterface *filesystem) {
default_filesystem_ = filesystem;
}
static FilesystemInterface *swap_default_filesystem(
FilesystemInterface *filesystem) {
FilesystemInterface *cur = default_filesystem_;
default_filesystem_ = filesystem;
return cur;
}
static DirectoryIterator *IterateDirectory() {
return EnsureDefaultFilesystem()->IterateDirectory();
}
static bool CreateFolder(const Pathname &pathname) {
return EnsureDefaultFilesystem()->CreateFolder(pathname);
}
static FileStream *OpenFile(const Pathname &filename,
const std::string &mode) {
return EnsureDefaultFilesystem()->OpenFile(filename, mode);
}
static bool CreatePrivateFile(const Pathname &filename) {
return EnsureDefaultFilesystem()->CreatePrivateFile(filename);
}
static bool DeleteFile(const Pathname &filename) {
return EnsureDefaultFilesystem()->DeleteFile(filename);
}
static bool DeleteEmptyFolder(const Pathname &folder) {
return EnsureDefaultFilesystem()->DeleteEmptyFolder(folder);
}
static bool DeleteFolderContents(const Pathname &folder) {
return EnsureDefaultFilesystem()->DeleteFolderContents(folder);
}
static bool DeleteFolderAndContents(const Pathname &folder) {
return EnsureDefaultFilesystem()->DeleteFolderAndContents(folder);
}
static bool MoveFolder(const Pathname &old_path, const Pathname &new_path) {
return EnsureDefaultFilesystem()->MoveFolder(old_path, new_path);
}
static bool MoveFile(const Pathname &old_path, const Pathname &new_path) {
return EnsureDefaultFilesystem()->MoveFile(old_path, new_path);
}
static bool CopyFolder(const Pathname &old_path, const Pathname &new_path) {
return EnsureDefaultFilesystem()->CopyFolder(old_path, new_path);
}
static bool CopyFile(const Pathname &old_path, const Pathname &new_path) {
return EnsureDefaultFilesystem()->CopyFile(old_path, new_path);
}
static bool IsFolder(const Pathname& pathname) {
return EnsureDefaultFilesystem()->IsFolder(pathname);
}
static bool IsFile(const Pathname &pathname) {
return EnsureDefaultFilesystem()->IsFile(pathname);
}
static bool IsAbsent(const Pathname &pathname) {
return EnsureDefaultFilesystem()->IsAbsent(pathname);
}
static bool IsTemporaryPath(const Pathname& pathname) {
return EnsureDefaultFilesystem()->IsTemporaryPath(pathname);
}
static bool GetTemporaryFolder(Pathname &path, bool create,
const std::string *append) {
return EnsureDefaultFilesystem()->GetTemporaryFolder(path, create, append);
}
static std::string TempFilename(const Pathname &dir,
const std::string &prefix) {
return EnsureDefaultFilesystem()->TempFilename(dir, prefix);
}
static bool GetFileSize(const Pathname& path, size_t* size) {
return EnsureDefaultFilesystem()->GetFileSize(path, size);
}
static bool GetFileTime(const Pathname& path, FileTimeType which,
time_t* time) {
return EnsureDefaultFilesystem()->GetFileTime(path, which, time);
}
static bool GetAppPathname(Pathname* path) {
return EnsureDefaultFilesystem()->GetAppPathname(path);
}
static bool GetAppDataFolder(Pathname* path, bool per_user) {
return EnsureDefaultFilesystem()->GetAppDataFolder(path, per_user);
}
static bool GetAppTempFolder(Pathname* path) {
return EnsureDefaultFilesystem()->GetAppTempFolder(path);
}
static bool CleanAppTempFolder() {
return EnsureDefaultFilesystem()->CleanAppTempFolder();
}
static bool GetDiskFreeSpace(const Pathname& path, int64_t* freebytes) {
return EnsureDefaultFilesystem()->GetDiskFreeSpace(path, freebytes);
}
// Definition has to be in the .cc file due to returning forward-declared
// Pathname by value.
static Pathname GetCurrentDirectory();
static void SetOrganizationName(const std::string& organization) {
EnsureDefaultFilesystem()->SetOrganizationName(organization);
}
static void GetOrganizationName(std::string* organization) {
EnsureDefaultFilesystem()->GetOrganizationName(organization);
}
static void SetApplicationName(const std::string& application) {
EnsureDefaultFilesystem()->SetApplicationName(application);
}
static void GetApplicationName(std::string* application) {
EnsureDefaultFilesystem()->GetApplicationName(application);
}
private:
static FilesystemInterface* default_filesystem_;
static FilesystemInterface *EnsureDefaultFilesystem();
RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(Filesystem);
};
class FilesystemScope{
public:
explicit FilesystemScope(FilesystemInterface *new_fs) {
old_fs_ = Filesystem::swap_default_filesystem(new_fs);
}
~FilesystemScope() {
Filesystem::set_default_filesystem(old_fs_);
}
private:
FilesystemInterface* old_fs_;
RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(FilesystemScope);
};
// Generates a unique filename based on the input path. If no path component
// is specified, it uses the temporary directory. If a filename is provided,
// up to 100 variations of form basename-N.extension are tried. When
// create_empty is true, an empty file of this name is created (which
// decreases the chance of a temporary filename collision with another
// process).
bool CreateUniqueFile(Pathname& path, bool create_empty);
} // namespace rtc
#endif // WEBRTC_BASE_FILEUTILS_H_