fs/Path: rename to AllocatedPath
The new class Path only holds a string pointer without being responsible for allocation/deallocation. The FileSystem.hxx library accepts Path arguments instead of AllocatedPath, to avoid forcing callers to allocate another string object.
This commit is contained in:
parent
b3611524f4
commit
abfbd55305
@ -348,6 +348,7 @@ libfs_a_SOURCES = \
|
||||
src/fs/Config.cxx src/fs/Config.hxx \
|
||||
src/fs/Charset.cxx src/fs/Charset.hxx \
|
||||
src/fs/Path.cxx src/fs/Path.hxx \
|
||||
src/fs/AllocatedPath.cxx src/fs/AllocatedPath.hxx \
|
||||
src/fs/FileSystem.cxx src/fs/FileSystem.hxx \
|
||||
src/fs/DirectoryReader.hxx
|
||||
|
||||
|
@ -32,8 +32,7 @@
|
||||
#include <unistd.h>
|
||||
|
||||
bool
|
||||
client_allow_file(const Client *client, const Path &path_fs,
|
||||
Error &error)
|
||||
client_allow_file(const Client *client, Path path_fs, Error &error)
|
||||
{
|
||||
#ifdef WIN32
|
||||
(void)client;
|
||||
|
@ -35,7 +35,6 @@ class Error;
|
||||
* @return true if access is allowed
|
||||
*/
|
||||
bool
|
||||
client_allow_file(const Client *client, const Path &path_fs,
|
||||
Error &error);
|
||||
client_allow_file(const Client *client, Path path_fs, Error &error);
|
||||
|
||||
#endif
|
||||
|
@ -31,7 +31,7 @@
|
||||
#include "InputPlugin.hxx"
|
||||
#include "PlaylistRegistry.hxx"
|
||||
#include "PlaylistPlugin.hxx"
|
||||
#include "fs/Path.hxx"
|
||||
#include "fs/AllocatedPath.hxx"
|
||||
#include "fs/Traits.hxx"
|
||||
#include "fs/FileSystem.hxx"
|
||||
#include "util/Error.hxx"
|
||||
@ -136,13 +136,13 @@ static const char *summary =
|
||||
"Music Player Daemon - a daemon for playing music.";
|
||||
|
||||
gcc_pure
|
||||
static Path
|
||||
PathBuildChecked(const Path &a, PathTraits::const_pointer b)
|
||||
static AllocatedPath
|
||||
PathBuildChecked(const AllocatedPath &a, PathTraits::const_pointer b)
|
||||
{
|
||||
if (a.IsNull())
|
||||
return Path::Null();
|
||||
return AllocatedPath::Null();
|
||||
|
||||
return Path::Build(a, b);
|
||||
return AllocatedPath::Build(a, b);
|
||||
}
|
||||
|
||||
bool
|
||||
@ -206,7 +206,7 @@ parse_cmdline(int argc, char **argv, struct options *options,
|
||||
/* default configuration file path */
|
||||
|
||||
#ifdef WIN32
|
||||
Path path = PathBuildChecked(Path::FromUTF8(g_get_user_config_dir()),
|
||||
AllocatedPath path = PathBuildChecked(AllocatedPath::FromUTF8(g_get_user_config_dir()),
|
||||
CONFIG_FILE_LOCATION);
|
||||
if (!path.IsNull() && FileExists(path))
|
||||
return ReadConfigFile(path, error);
|
||||
@ -215,28 +215,28 @@ parse_cmdline(int argc, char **argv, struct options *options,
|
||||
g_get_system_config_dirs();
|
||||
|
||||
for (unsigned i = 0; system_config_dirs[i] != nullptr; ++i) {
|
||||
path = PathBuildChecked(Path::FromUTF8(system_config_dirs[i]),
|
||||
path = PathBuildChecked(AllocatedPath::FromUTF8(system_config_dirs[i]),
|
||||
CONFIG_FILE_LOCATION);
|
||||
if (!path.IsNull() && FileExists(path))
|
||||
return ReadConfigFile(path, error);
|
||||
}
|
||||
#else
|
||||
Path path = PathBuildChecked(Path::FromUTF8(g_get_user_config_dir()),
|
||||
AllocatedPath path = PathBuildChecked(AllocatedPath::FromUTF8(g_get_user_config_dir()),
|
||||
USER_CONFIG_FILE_LOCATION_XDG);
|
||||
if (!path.IsNull() && FileExists(path))
|
||||
return ReadConfigFile(path, error);
|
||||
|
||||
path = PathBuildChecked(Path::FromUTF8(g_get_home_dir()),
|
||||
path = PathBuildChecked(AllocatedPath::FromUTF8(g_get_home_dir()),
|
||||
USER_CONFIG_FILE_LOCATION1);
|
||||
if (!path.IsNull() && FileExists(path))
|
||||
return ReadConfigFile(path, error);
|
||||
|
||||
path = PathBuildChecked(Path::FromUTF8(g_get_home_dir()),
|
||||
path = PathBuildChecked(AllocatedPath::FromUTF8(g_get_home_dir()),
|
||||
USER_CONFIG_FILE_LOCATION2);
|
||||
if (!path.IsNull() && FileExists(path))
|
||||
return ReadConfigFile(path, error);
|
||||
|
||||
path = Path::FromUTF8(SYSTEM_CONFIG_FILE_LOCATION);
|
||||
path = AllocatedPath::FromUTF8(SYSTEM_CONFIG_FILE_LOCATION);
|
||||
if (!path.IsNull() && FileExists(path))
|
||||
return ReadConfigFile(path, error);
|
||||
#endif
|
||||
|
@ -22,7 +22,7 @@
|
||||
#include "ConfigParser.hxx"
|
||||
#include "ConfigPath.hxx"
|
||||
#include "util/Error.hxx"
|
||||
#include "fs/Path.hxx"
|
||||
#include "fs/AllocatedPath.hxx"
|
||||
#include "system/FatalError.hxx"
|
||||
|
||||
#include <assert.h>
|
||||
@ -86,7 +86,7 @@ config_param::GetBlockValue(const char *name, const char *default_value) const
|
||||
return bp->value.c_str();
|
||||
}
|
||||
|
||||
Path
|
||||
AllocatedPath
|
||||
config_param::GetBlockPath(const char *name, const char *default_value,
|
||||
Error &error) const
|
||||
{
|
||||
@ -101,12 +101,12 @@ config_param::GetBlockPath(const char *name, const char *default_value,
|
||||
s = bp->value.c_str();
|
||||
} else {
|
||||
if (default_value == nullptr)
|
||||
return Path::Null();
|
||||
return AllocatedPath::Null();
|
||||
|
||||
s = default_value;
|
||||
}
|
||||
|
||||
Path path = ParsePath(s, error);
|
||||
AllocatedPath path = ParsePath(s, error);
|
||||
if (gcc_unlikely(path.IsNull()))
|
||||
error.FormatPrefix("Invalid path in \"%s\" at line %i: ",
|
||||
name, line2);
|
||||
@ -114,7 +114,7 @@ config_param::GetBlockPath(const char *name, const char *default_value,
|
||||
return path;
|
||||
}
|
||||
|
||||
Path
|
||||
AllocatedPath
|
||||
config_param::GetBlockPath(const char *name, Error &error) const
|
||||
{
|
||||
return GetBlockPath(name, nullptr, error);
|
||||
|
@ -27,7 +27,7 @@
|
||||
#include <array>
|
||||
#include <vector>
|
||||
|
||||
class Path;
|
||||
class AllocatedPath;
|
||||
class Error;
|
||||
|
||||
struct block_param {
|
||||
@ -109,10 +109,10 @@ struct config_param {
|
||||
* Same as config_dup_path(), but looks up the setting in the
|
||||
* specified block.
|
||||
*/
|
||||
Path GetBlockPath(const char *name, const char *default_value,
|
||||
AllocatedPath GetBlockPath(const char *name, const char *default_value,
|
||||
Error &error) const;
|
||||
|
||||
Path GetBlockPath(const char *name, Error &error) const;
|
||||
AllocatedPath GetBlockPath(const char *name, Error &error) const;
|
||||
|
||||
gcc_pure
|
||||
unsigned GetBlockValue(const char *name, unsigned default_value) const;
|
||||
|
@ -253,7 +253,7 @@ ReadConfigFile(ConfigData &config_data, FILE *fp, Error &error)
|
||||
}
|
||||
|
||||
bool
|
||||
ReadConfigFile(ConfigData &config_data, const Path &path, Error &error)
|
||||
ReadConfigFile(ConfigData &config_data, Path path, Error &error)
|
||||
{
|
||||
assert(!path.IsNull());
|
||||
const std::string path_utf8 = path.ToUTF8();
|
||||
|
@ -25,6 +25,6 @@ class Path;
|
||||
struct ConfigData;
|
||||
|
||||
bool
|
||||
ReadConfigFile(ConfigData &data, const Path &path, Error &error);
|
||||
ReadConfigFile(ConfigData &data, Path path, Error &error);
|
||||
|
||||
#endif
|
||||
|
@ -25,6 +25,7 @@
|
||||
#include "ConfigPath.hxx"
|
||||
#include "ConfigError.hxx"
|
||||
#include "fs/Path.hxx"
|
||||
#include "fs/AllocatedPath.hxx"
|
||||
#include "util/Error.hxx"
|
||||
#include "system/FatalError.hxx"
|
||||
#include "Log.hxx"
|
||||
@ -45,7 +46,7 @@ void config_global_init(void)
|
||||
}
|
||||
|
||||
bool
|
||||
ReadConfigFile(const Path &path, Error &error)
|
||||
ReadConfigFile(Path path, Error &error)
|
||||
{
|
||||
return ReadConfigFile(config_data, path, error);
|
||||
}
|
||||
@ -96,20 +97,20 @@ config_get_string(ConfigOption option, const char *default_value)
|
||||
return param->value.c_str();
|
||||
}
|
||||
|
||||
Path
|
||||
AllocatedPath
|
||||
config_get_path(ConfigOption option, Error &error)
|
||||
{
|
||||
const struct config_param *param = config_get_param(option);
|
||||
if (param == nullptr)
|
||||
return Path::Null();
|
||||
return AllocatedPath::Null();
|
||||
|
||||
return config_parse_path(param, error);
|
||||
}
|
||||
|
||||
Path
|
||||
AllocatedPath
|
||||
config_parse_path(const struct config_param *param, Error & error)
|
||||
{
|
||||
Path path = ParsePath(param->value.c_str(), error);
|
||||
AllocatedPath path = ParsePath(param->value.c_str(), error);
|
||||
if (gcc_unlikely(path.IsNull()))
|
||||
error.FormatPrefix("Invalid path at line %i: ",
|
||||
param->line);
|
||||
|
@ -25,6 +25,7 @@
|
||||
|
||||
class Error;
|
||||
class Path;
|
||||
class AllocatedPath;
|
||||
|
||||
void config_global_init(void);
|
||||
void config_global_finish(void);
|
||||
@ -36,7 +37,7 @@ void config_global_finish(void);
|
||||
void config_global_check(void);
|
||||
|
||||
bool
|
||||
ReadConfigFile(const Path &path, Error &error);
|
||||
ReadConfigFile(Path path, Error &error);
|
||||
|
||||
/* don't free the returned value
|
||||
set _last_ to nullptr to get first entry */
|
||||
@ -66,18 +67,18 @@ config_get_string(enum ConfigOption option, const char *default_value);
|
||||
/**
|
||||
* Returns an optional configuration variable which contains an
|
||||
* absolute path. If there is a tilde prefix, it is expanded.
|
||||
* Returns Path::Null() if the value is not present. If the path
|
||||
* could not be parsed, returns Path::Null() and sets the error.
|
||||
* Returns AllocatedPath::Null() if the value is not present. If the path
|
||||
* could not be parsed, returns AllocatedPath::Null() and sets the error.
|
||||
*/
|
||||
Path
|
||||
AllocatedPath
|
||||
config_get_path(enum ConfigOption option, Error &error);
|
||||
|
||||
/**
|
||||
* Parse a configuration parameter as a path.
|
||||
* If there is a tilde prefix, it is expanded. If the path could
|
||||
* not be parsed, returns Path::Null() and sets the error.
|
||||
* not be parsed, returns AllocatedPath::Null() and sets the error.
|
||||
*/
|
||||
Path
|
||||
AllocatedPath
|
||||
config_parse_path(const struct config_param *param, Error & error_r);
|
||||
|
||||
gcc_pure
|
||||
|
@ -19,7 +19,7 @@
|
||||
|
||||
#include "config.h"
|
||||
#include "ConfigPath.hxx"
|
||||
#include "fs/Path.hxx"
|
||||
#include "fs/AllocatedPath.hxx"
|
||||
#include "fs/Traits.hxx"
|
||||
#include "fs/Domain.hxx"
|
||||
#include "util/Error.hxx"
|
||||
@ -36,39 +36,39 @@
|
||||
/**
|
||||
* Determine a given user's home directory.
|
||||
*/
|
||||
static Path
|
||||
static AllocatedPath
|
||||
GetHome(const char *user, Error &error)
|
||||
{
|
||||
passwd *pw = getpwnam(user);
|
||||
if (pw == nullptr) {
|
||||
error.Format(path_domain,
|
||||
"no such user: %s", user);
|
||||
return Path::Null();
|
||||
return AllocatedPath::Null();
|
||||
}
|
||||
|
||||
return Path::FromFS(pw->pw_dir);
|
||||
return AllocatedPath::FromFS(pw->pw_dir);
|
||||
}
|
||||
|
||||
/**
|
||||
* Determine the current user's home directory.
|
||||
*/
|
||||
static Path
|
||||
static AllocatedPath
|
||||
GetHome(Error &error)
|
||||
{
|
||||
const char *home = g_get_home_dir();
|
||||
if (home == nullptr) {
|
||||
error.Set(path_domain,
|
||||
"problems getting home for current user");
|
||||
return Path::Null();
|
||||
return AllocatedPath::Null();
|
||||
}
|
||||
|
||||
return Path::FromUTF8(home, error);
|
||||
return AllocatedPath::FromUTF8(home, error);
|
||||
}
|
||||
|
||||
/**
|
||||
* Determine the configured user's home directory.
|
||||
*/
|
||||
static Path
|
||||
static AllocatedPath
|
||||
GetConfiguredHome(Error &error)
|
||||
{
|
||||
const char *user = config_get_string(CONF_USER, nullptr);
|
||||
@ -79,7 +79,7 @@ GetConfiguredHome(Error &error)
|
||||
|
||||
#endif
|
||||
|
||||
Path
|
||||
AllocatedPath
|
||||
ParsePath(const char *path, Error &error)
|
||||
{
|
||||
assert(path != nullptr);
|
||||
@ -91,7 +91,7 @@ ParsePath(const char *path, Error &error)
|
||||
if (*path == '\0')
|
||||
return GetConfiguredHome(error);
|
||||
|
||||
Path home = Path::Null();
|
||||
AllocatedPath home = AllocatedPath::Null();
|
||||
|
||||
if (*path == '/') {
|
||||
home = GetConfiguredHome(error);
|
||||
@ -113,20 +113,20 @@ ParsePath(const char *path, Error &error)
|
||||
}
|
||||
|
||||
if (home.IsNull())
|
||||
return Path::Null();
|
||||
return AllocatedPath::Null();
|
||||
|
||||
Path path2 = Path::FromUTF8(path, error);
|
||||
AllocatedPath path2 = AllocatedPath::FromUTF8(path, error);
|
||||
if (path2.IsNull())
|
||||
return Path::Null();
|
||||
return AllocatedPath::Null();
|
||||
|
||||
return Path::Build(home, path2);
|
||||
return AllocatedPath::Build(home, path2);
|
||||
} else if (!PathTraits::IsAbsoluteUTF8(path)) {
|
||||
error.Format(path_domain,
|
||||
"not an absolute path: %s", path);
|
||||
return Path::Null();
|
||||
return AllocatedPath::Null();
|
||||
} else {
|
||||
#endif
|
||||
return Path::FromUTF8(path, error);
|
||||
return AllocatedPath::FromUTF8(path, error);
|
||||
#ifndef WIN32
|
||||
}
|
||||
#endif
|
||||
|
@ -20,10 +20,10 @@
|
||||
#ifndef MPD_CONFIG_PATH_HXX
|
||||
#define MPD_CONFIG_PATH_HXX
|
||||
|
||||
class Path;
|
||||
class AllocatedPath;
|
||||
class Error;
|
||||
|
||||
Path
|
||||
AllocatedPath
|
||||
ParsePath(const char *path, Error &error);
|
||||
|
||||
#endif
|
||||
|
@ -20,7 +20,7 @@
|
||||
#include "config.h"
|
||||
#include "Daemon.hxx"
|
||||
#include "system/FatalError.hxx"
|
||||
#include "fs/Path.hxx"
|
||||
#include "fs/AllocatedPath.hxx"
|
||||
#include "fs/FileSystem.hxx"
|
||||
#include "util/Domain.hxx"
|
||||
#include "Log.hxx"
|
||||
@ -55,7 +55,7 @@ static uid_t user_uid = (uid_t)-1;
|
||||
static gid_t user_gid = (pid_t)-1;
|
||||
|
||||
/** the absolute path of the pidfile */
|
||||
static Path pidfile = Path::Null();
|
||||
static AllocatedPath pidfile = AllocatedPath::Null();
|
||||
|
||||
/* whether "group" conf. option was given */
|
||||
static bool had_group = false;
|
||||
@ -202,7 +202,7 @@ daemonize(bool detach)
|
||||
}
|
||||
|
||||
void
|
||||
daemonize_init(const char *user, const char *group, Path &&_pidfile)
|
||||
daemonize_init(const char *user, const char *group, AllocatedPath &&_pidfile)
|
||||
{
|
||||
if (user) {
|
||||
struct passwd *pwd = getpwnam(user);
|
||||
@ -235,7 +235,7 @@ daemonize_finish(void)
|
||||
{
|
||||
if (!pidfile.IsNull()) {
|
||||
RemoveFile(pidfile);
|
||||
pidfile = Path::Null();
|
||||
pidfile = AllocatedPath::Null();
|
||||
}
|
||||
|
||||
g_free(user_name);
|
||||
|
@ -20,14 +20,14 @@
|
||||
#ifndef MPD_DAEMON_HXX
|
||||
#define MPD_DAEMON_HXX
|
||||
|
||||
class Path;
|
||||
class AllocatedPath;
|
||||
|
||||
#ifndef WIN32
|
||||
void
|
||||
daemonize_init(const char *user, const char *group, Path &&pidfile);
|
||||
daemonize_init(const char *user, const char *group, AllocatedPath &&pidfile);
|
||||
#else
|
||||
static inline void
|
||||
daemonize_init(const char *user, const char *group, Path &&pidfile)
|
||||
daemonize_init(const char *user, const char *group, AllocatedPath &&pidfile)
|
||||
{ (void)user; (void)group; (void)pidfile; }
|
||||
#endif
|
||||
|
||||
|
@ -27,7 +27,7 @@
|
||||
#include "system/FatalError.hxx"
|
||||
#include "Mapper.hxx"
|
||||
#include "fs/Traits.hxx"
|
||||
#include "fs/Path.hxx"
|
||||
#include "fs/AllocatedPath.hxx"
|
||||
#include "DecoderAPI.hxx"
|
||||
#include "tag/Tag.hxx"
|
||||
#include "InputStream.hxx"
|
||||
|
@ -37,7 +37,7 @@
|
||||
static constexpr Domain exclude_list_domain("exclude_list");
|
||||
|
||||
bool
|
||||
ExcludeList::LoadFile(const Path &path_fs)
|
||||
ExcludeList::LoadFile(Path path_fs)
|
||||
{
|
||||
FILE *file = FOpen(path_fs, FOpenMode::ReadText);
|
||||
if (file == NULL) {
|
||||
@ -69,7 +69,7 @@ ExcludeList::LoadFile(const Path &path_fs)
|
||||
}
|
||||
|
||||
bool
|
||||
ExcludeList::Check(const Path &name_fs) const
|
||||
ExcludeList::Check(Path name_fs) const
|
||||
{
|
||||
assert(!name_fs.IsNull());
|
||||
|
||||
|
@ -67,13 +67,13 @@ public:
|
||||
/**
|
||||
* Loads and parses a .mpdignore file.
|
||||
*/
|
||||
bool LoadFile(const Path &path_fs);
|
||||
bool LoadFile(Path path_fs);
|
||||
|
||||
/**
|
||||
* Checks whether one of the patterns in the .mpdignore file matches
|
||||
* the specified file name.
|
||||
*/
|
||||
bool Check(const Path &name_fs) const;
|
||||
bool Check(Path name_fs) const;
|
||||
};
|
||||
|
||||
|
||||
|
@ -24,7 +24,7 @@
|
||||
#include "InotifyDomain.hxx"
|
||||
#include "Mapper.hxx"
|
||||
#include "Main.hxx"
|
||||
#include "fs/Path.hxx"
|
||||
#include "fs/AllocatedPath.hxx"
|
||||
#include "fs/FileSystem.hxx"
|
||||
#include "util/Error.hxx"
|
||||
#include "Log.hxx"
|
||||
@ -50,7 +50,7 @@ enum {
|
||||
struct WatchDirectory {
|
||||
WatchDirectory *parent;
|
||||
|
||||
Path name;
|
||||
AllocatedPath name;
|
||||
|
||||
int descriptor;
|
||||
|
||||
@ -129,17 +129,17 @@ remove_watch_directory(WatchDirectory *directory)
|
||||
});
|
||||
}
|
||||
|
||||
static Path
|
||||
static AllocatedPath
|
||||
watch_directory_get_uri_fs(const WatchDirectory *directory)
|
||||
{
|
||||
if (directory->parent == NULL)
|
||||
return Path::Null();
|
||||
return AllocatedPath::Null();
|
||||
|
||||
Path uri = watch_directory_get_uri_fs(directory->parent);
|
||||
const auto uri = watch_directory_get_uri_fs(directory->parent);
|
||||
if (uri.IsNull())
|
||||
return directory->name;
|
||||
|
||||
return Path::Build(uri, directory->name);
|
||||
return AllocatedPath::Build(uri, directory->name);
|
||||
}
|
||||
|
||||
/* we don't look at "." / ".." nor files with newlines in their name */
|
||||
@ -152,7 +152,7 @@ static bool skip_path(const char *path)
|
||||
|
||||
static void
|
||||
recursive_watch_subdirectories(WatchDirectory *directory,
|
||||
const Path &path_fs, unsigned depth)
|
||||
const AllocatedPath &path_fs, unsigned depth)
|
||||
{
|
||||
Error error;
|
||||
DIR *dir;
|
||||
@ -181,7 +181,8 @@ recursive_watch_subdirectories(WatchDirectory *directory,
|
||||
if (skip_path(ent->d_name))
|
||||
continue;
|
||||
|
||||
const Path child_path_fs = Path::Build(path_fs, ent->d_name);
|
||||
const auto child_path_fs =
|
||||
AllocatedPath::Build(path_fs, ent->d_name);
|
||||
ret = StatFile(child_path_fs, st);
|
||||
if (ret < 0) {
|
||||
FormatErrno(inotify_domain,
|
||||
@ -209,7 +210,7 @@ recursive_watch_subdirectories(WatchDirectory *directory,
|
||||
continue;
|
||||
|
||||
directory->children.emplace_front(directory,
|
||||
Path::FromFS(ent->d_name),
|
||||
AllocatedPath::FromFS(ent->d_name),
|
||||
ret);
|
||||
child = &directory->children.front();
|
||||
|
||||
@ -257,11 +258,11 @@ mpd_inotify_callback(int wd, unsigned mask,
|
||||
(mask & IN_ISDIR) != 0) {
|
||||
/* a sub directory was changed: register those in
|
||||
inotify */
|
||||
const Path &root = mapper_get_music_directory_fs();
|
||||
const auto &root = mapper_get_music_directory_fs();
|
||||
|
||||
const Path path_fs = uri_fs.IsNull()
|
||||
const auto path_fs = uri_fs.IsNull()
|
||||
? root
|
||||
: Path::Build(root, uri_fs.c_str());
|
||||
: AllocatedPath::Build(root, uri_fs.c_str());
|
||||
|
||||
recursive_watch_subdirectories(directory, path_fs,
|
||||
watch_directory_depth(directory));
|
||||
@ -290,7 +291,7 @@ mpd_inotify_init(unsigned max_depth)
|
||||
{
|
||||
LogDebug(inotify_domain, "initializing inotify");
|
||||
|
||||
const Path &path = mapper_get_music_directory_fs();
|
||||
const auto &path = mapper_get_music_directory_fs();
|
||||
if (path.IsNull()) {
|
||||
LogDebug(inotify_domain, "no music directory configured");
|
||||
return;
|
||||
|
@ -28,7 +28,7 @@
|
||||
#include "event/ServerSocket.hxx"
|
||||
#include "util/Error.hxx"
|
||||
#include "util/Domain.hxx"
|
||||
#include "fs/Path.hxx"
|
||||
#include "fs/AllocatedPath.hxx"
|
||||
#include "Log.hxx"
|
||||
|
||||
#include <string.h>
|
||||
@ -67,7 +67,7 @@ listen_add_config_param(unsigned int port,
|
||||
if (0 == strcmp(param->value.c_str(), "any")) {
|
||||
return listen_socket->AddPort(port, error_r);
|
||||
} else if (param->value[0] == '/' || param->value[0] == '~') {
|
||||
Path path = config_parse_path(param, error_r);
|
||||
const auto path = config_parse_path(param, error_r);
|
||||
return !path.IsNull() && listen_socket->AddPath(path.c_str(), error_r);
|
||||
} else {
|
||||
return listen_socket->AddHost(param->value.c_str(), port,
|
||||
|
@ -25,7 +25,7 @@
|
||||
#include "ConfigOption.hxx"
|
||||
#include "system/fd_util.h"
|
||||
#include "system/FatalError.hxx"
|
||||
#include "fs/Path.hxx"
|
||||
#include "fs/AllocatedPath.hxx"
|
||||
#include "fs/FileSystem.hxx"
|
||||
#include "util/Error.hxx"
|
||||
#include "util/Domain.hxx"
|
||||
@ -61,7 +61,7 @@ static const char *log_charset;
|
||||
|
||||
static bool stdout_mode = true;
|
||||
static int out_fd;
|
||||
static Path out_path = Path::Null();
|
||||
static AllocatedPath out_path = AllocatedPath::Null();
|
||||
|
||||
static void redirect_logs(int fd)
|
||||
{
|
||||
@ -301,7 +301,7 @@ void
|
||||
log_deinit(void)
|
||||
{
|
||||
close_log_files();
|
||||
out_path = Path::Null();
|
||||
out_path = AllocatedPath::Null();
|
||||
}
|
||||
|
||||
|
||||
|
19
src/Main.cxx
19
src/Main.cxx
@ -48,7 +48,7 @@
|
||||
#include "InputInit.hxx"
|
||||
#include "event/Loop.hxx"
|
||||
#include "IOThread.hxx"
|
||||
#include "fs/Path.hxx"
|
||||
#include "fs/AllocatedPath.hxx"
|
||||
#include "fs/Config.hxx"
|
||||
#include "PlaylistRegistry.hxx"
|
||||
#include "ZeroconfGlue.hxx"
|
||||
@ -111,7 +111,7 @@ static StateFile *state_file;
|
||||
static bool
|
||||
glue_daemonize_init(const struct options *options, Error &error)
|
||||
{
|
||||
Path pid_file = config_get_path(CONF_PID_FILE, error);
|
||||
auto pid_file = config_get_path(CONF_PID_FILE, error);
|
||||
if (pid_file.IsNull() && error.IsDefined())
|
||||
return false;
|
||||
|
||||
@ -128,16 +128,16 @@ glue_daemonize_init(const struct options *options, Error &error)
|
||||
static bool
|
||||
glue_mapper_init(Error &error)
|
||||
{
|
||||
Path music_dir = config_get_path(CONF_MUSIC_DIR, error);
|
||||
auto music_dir = config_get_path(CONF_MUSIC_DIR, error);
|
||||
if (music_dir.IsNull() && error.IsDefined())
|
||||
return false;
|
||||
|
||||
Path playlist_dir = config_get_path(CONF_PLAYLIST_DIR, error);
|
||||
auto playlist_dir = config_get_path(CONF_PLAYLIST_DIR, error);
|
||||
if (playlist_dir.IsNull() && error.IsDefined())
|
||||
return false;
|
||||
|
||||
if (music_dir.IsNull()) {
|
||||
music_dir = Path::FromUTF8(g_get_user_special_dir(G_USER_DIRECTORY_MUSIC),
|
||||
music_dir = AllocatedPath::FromUTF8(g_get_user_special_dir(G_USER_DIRECTORY_MUSIC),
|
||||
error);
|
||||
if (music_dir.IsNull())
|
||||
return false;
|
||||
@ -207,9 +207,12 @@ glue_sticker_init(void)
|
||||
{
|
||||
#ifdef ENABLE_SQLITE
|
||||
Error error;
|
||||
Path sticker_file = config_get_path(CONF_STICKER_FILE, error);
|
||||
if (sticker_file.IsNull() && error.IsDefined())
|
||||
auto sticker_file = config_get_path(CONF_STICKER_FILE, error);
|
||||
if (sticker_file.IsNull()) {
|
||||
if (error.IsDefined())
|
||||
FatalError(error);
|
||||
return;
|
||||
}
|
||||
|
||||
if (!sticker_global_init(std::move(sticker_file), error))
|
||||
FatalError(error);
|
||||
@ -219,7 +222,7 @@ glue_sticker_init(void)
|
||||
static bool
|
||||
glue_state_file_init(Error &error)
|
||||
{
|
||||
Path path_fs = config_get_path(CONF_STATE_FILE, error);
|
||||
auto path_fs = config_get_path(CONF_STATE_FILE, error);
|
||||
if (path_fs.IsNull())
|
||||
return !error.IsDefined();
|
||||
|
||||
|
@ -25,7 +25,7 @@
|
||||
#include "Mapper.hxx"
|
||||
#include "Directory.hxx"
|
||||
#include "Song.hxx"
|
||||
#include "fs/Path.hxx"
|
||||
#include "fs/AllocatedPath.hxx"
|
||||
#include "fs/Traits.hxx"
|
||||
#include "fs/Charset.hxx"
|
||||
#include "fs/FileSystem.hxx"
|
||||
@ -52,16 +52,16 @@ static size_t music_dir_utf8_length;
|
||||
* The absolute path of the music directory encoded in the filesystem
|
||||
* character set.
|
||||
*/
|
||||
static Path music_dir_fs = Path::Null();
|
||||
static AllocatedPath music_dir_fs = AllocatedPath::Null();
|
||||
|
||||
/**
|
||||
* The absolute path of the playlist directory encoded in the
|
||||
* filesystem character set.
|
||||
*/
|
||||
static Path playlist_dir_fs = Path::Null();
|
||||
static AllocatedPath playlist_dir_fs = AllocatedPath::Null();
|
||||
|
||||
static void
|
||||
check_directory(const char *path_utf8, const Path &path_fs)
|
||||
check_directory(const char *path_utf8, const AllocatedPath &path_fs)
|
||||
{
|
||||
struct stat st;
|
||||
if (!StatFile(path_fs, st)) {
|
||||
@ -78,7 +78,7 @@ check_directory(const char *path_utf8, const Path &path_fs)
|
||||
}
|
||||
|
||||
#ifndef WIN32
|
||||
const Path x = Path::Build(path_fs, ".");
|
||||
const auto x = AllocatedPath::Build(path_fs, ".");
|
||||
if (!StatFile(x, st) && errno == EACCES)
|
||||
FormatError(mapper_domain,
|
||||
"No permission to traverse (\"execute\") directory: %s",
|
||||
@ -92,7 +92,7 @@ check_directory(const char *path_utf8, const Path &path_fs)
|
||||
}
|
||||
|
||||
static void
|
||||
mapper_set_music_dir(Path &&path)
|
||||
mapper_set_music_dir(AllocatedPath &&path)
|
||||
{
|
||||
assert(!path.IsNull());
|
||||
|
||||
@ -106,7 +106,7 @@ mapper_set_music_dir(Path &&path)
|
||||
}
|
||||
|
||||
static void
|
||||
mapper_set_playlist_dir(Path &&path)
|
||||
mapper_set_playlist_dir(AllocatedPath &&path)
|
||||
{
|
||||
assert(!path.IsNull());
|
||||
|
||||
@ -117,7 +117,7 @@ mapper_set_playlist_dir(Path &&path)
|
||||
}
|
||||
|
||||
void
|
||||
mapper_init(Path &&_music_dir, Path &&_playlist_dir)
|
||||
mapper_init(AllocatedPath &&_music_dir, AllocatedPath &&_playlist_dir)
|
||||
{
|
||||
if (!_music_dir.IsNull())
|
||||
mapper_set_music_dir(std::move(_music_dir));
|
||||
@ -136,7 +136,7 @@ mapper_get_music_directory_utf8(void)
|
||||
return music_dir_utf8.c_str();
|
||||
}
|
||||
|
||||
const Path &
|
||||
const AllocatedPath &
|
||||
mapper_get_music_directory_fs(void)
|
||||
{
|
||||
return music_dir_fs;
|
||||
@ -153,23 +153,23 @@ map_to_relative_path(const char *path_utf8)
|
||||
: path_utf8;
|
||||
}
|
||||
|
||||
Path
|
||||
AllocatedPath
|
||||
map_uri_fs(const char *uri)
|
||||
{
|
||||
assert(uri != NULL);
|
||||
assert(*uri != '/');
|
||||
|
||||
if (music_dir_fs.IsNull())
|
||||
return Path::Null();
|
||||
return AllocatedPath::Null();
|
||||
|
||||
const Path uri_fs = Path::FromUTF8(uri);
|
||||
const auto uri_fs = AllocatedPath::FromUTF8(uri);
|
||||
if (uri_fs.IsNull())
|
||||
return Path::Null();
|
||||
return AllocatedPath::Null();
|
||||
|
||||
return Path::Build(music_dir_fs, uri_fs);
|
||||
return AllocatedPath::Build(music_dir_fs, uri_fs);
|
||||
}
|
||||
|
||||
Path
|
||||
AllocatedPath
|
||||
map_directory_fs(const Directory *directory)
|
||||
{
|
||||
assert(!music_dir_fs.IsNull());
|
||||
@ -180,7 +180,7 @@ map_directory_fs(const Directory *directory)
|
||||
return map_uri_fs(directory->GetPath());
|
||||
}
|
||||
|
||||
Path
|
||||
AllocatedPath
|
||||
map_directory_child_fs(const Directory *directory, const char *name)
|
||||
{
|
||||
assert(!music_dir_fs.IsNull());
|
||||
@ -188,17 +188,17 @@ map_directory_child_fs(const Directory *directory, const char *name)
|
||||
/* check for invalid or unauthorized base names */
|
||||
if (*name == 0 || strchr(name, '/') != NULL ||
|
||||
strcmp(name, ".") == 0 || strcmp(name, "..") == 0)
|
||||
return Path::Null();
|
||||
return AllocatedPath::Null();
|
||||
|
||||
const Path parent_fs = map_directory_fs(directory);
|
||||
const auto parent_fs = map_directory_fs(directory);
|
||||
if (parent_fs.IsNull())
|
||||
return Path::Null();
|
||||
return AllocatedPath::Null();
|
||||
|
||||
const Path name_fs = Path::FromUTF8(name);
|
||||
const auto name_fs = AllocatedPath::FromUTF8(name);
|
||||
if (name_fs.IsNull())
|
||||
return Path::Null();
|
||||
return AllocatedPath::Null();
|
||||
|
||||
return Path::Build(parent_fs, name_fs);
|
||||
return AllocatedPath::Build(parent_fs, name_fs);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -206,17 +206,17 @@ map_directory_child_fs(const Directory *directory, const char *name)
|
||||
* not have a real parent directory, only the dummy object
|
||||
* #detached_root.
|
||||
*/
|
||||
static Path
|
||||
static AllocatedPath
|
||||
map_detached_song_fs(const char *uri_utf8)
|
||||
{
|
||||
Path uri_fs = Path::FromUTF8(uri_utf8);
|
||||
auto uri_fs = AllocatedPath::FromUTF8(uri_utf8);
|
||||
if (uri_fs.IsNull())
|
||||
return Path::Null();
|
||||
return uri_fs;
|
||||
|
||||
return Path::Build(music_dir_fs, uri_fs);
|
||||
return AllocatedPath::Build(music_dir_fs, uri_fs);
|
||||
}
|
||||
|
||||
Path
|
||||
AllocatedPath
|
||||
map_song_fs(const Song *song)
|
||||
{
|
||||
assert(song->IsFile());
|
||||
@ -226,7 +226,7 @@ map_song_fs(const Song *song)
|
||||
? map_detached_song_fs(song->uri)
|
||||
: map_directory_child_fs(song->parent, song->uri);
|
||||
else
|
||||
return Path::FromUTF8(song->uri);
|
||||
return AllocatedPath::FromUTF8(song->uri);
|
||||
}
|
||||
|
||||
std::string
|
||||
@ -241,24 +241,25 @@ map_fs_to_utf8(const char *path_fs)
|
||||
return PathToUTF8(path_fs);
|
||||
}
|
||||
|
||||
const Path &
|
||||
const AllocatedPath &
|
||||
map_spl_path(void)
|
||||
{
|
||||
return playlist_dir_fs;
|
||||
}
|
||||
|
||||
Path
|
||||
AllocatedPath
|
||||
map_spl_utf8_to_fs(const char *name)
|
||||
{
|
||||
if (playlist_dir_fs.IsNull())
|
||||
return Path::Null();
|
||||
return AllocatedPath::Null();
|
||||
|
||||
std::string filename_utf8 = name;
|
||||
filename_utf8.append(PLAYLIST_FILE_SUFFIX);
|
||||
|
||||
const Path filename_fs = Path::FromUTF8(filename_utf8.c_str());
|
||||
const auto filename_fs =
|
||||
AllocatedPath::FromUTF8(filename_utf8.c_str());
|
||||
if (filename_fs.IsNull())
|
||||
return Path::Null();
|
||||
return AllocatedPath::Null();
|
||||
|
||||
return Path::Build(playlist_dir_fs, filename_fs);
|
||||
return AllocatedPath::Build(playlist_dir_fs, filename_fs);
|
||||
}
|
||||
|
@ -31,11 +31,12 @@
|
||||
#define PLAYLIST_FILE_SUFFIX ".m3u"
|
||||
|
||||
class Path;
|
||||
class AllocatedPath;
|
||||
struct Directory;
|
||||
struct Song;
|
||||
|
||||
void
|
||||
mapper_init(Path &&music_dir, Path &&playlist_dir);
|
||||
mapper_init(AllocatedPath &&music_dir, AllocatedPath &&playlist_dir);
|
||||
|
||||
void mapper_finish(void);
|
||||
|
||||
@ -51,7 +52,7 @@ mapper_get_music_directory_utf8(void);
|
||||
* filesystem character set.
|
||||
*/
|
||||
gcc_const
|
||||
const Path &
|
||||
const AllocatedPath &
|
||||
mapper_get_music_directory_fs(void);
|
||||
|
||||
/**
|
||||
@ -79,7 +80,7 @@ map_to_relative_path(const char *path_utf8);
|
||||
* and prepending the music directory.
|
||||
*/
|
||||
gcc_pure
|
||||
Path
|
||||
AllocatedPath
|
||||
map_uri_fs(const char *uri);
|
||||
|
||||
/**
|
||||
@ -89,7 +90,7 @@ map_uri_fs(const char *uri);
|
||||
* @return the path in file system encoding, or nullptr if mapping failed
|
||||
*/
|
||||
gcc_pure
|
||||
Path
|
||||
AllocatedPath
|
||||
map_directory_fs(const Directory *directory);
|
||||
|
||||
/**
|
||||
@ -101,7 +102,7 @@ map_directory_fs(const Directory *directory);
|
||||
* @return the path in file system encoding, or nullptr if mapping failed
|
||||
*/
|
||||
gcc_pure
|
||||
Path
|
||||
AllocatedPath
|
||||
map_directory_child_fs(const Directory *directory, const char *name);
|
||||
|
||||
/**
|
||||
@ -112,7 +113,7 @@ map_directory_child_fs(const Directory *directory, const char *name);
|
||||
* @return the path in file system encoding, or nullptr if mapping failed
|
||||
*/
|
||||
gcc_pure
|
||||
Path
|
||||
AllocatedPath
|
||||
map_song_fs(const Song *song);
|
||||
|
||||
/**
|
||||
@ -131,7 +132,7 @@ map_fs_to_utf8(const char *path_fs);
|
||||
* Returns the playlist directory.
|
||||
*/
|
||||
gcc_const
|
||||
const Path &
|
||||
const AllocatedPath &
|
||||
map_spl_path(void);
|
||||
|
||||
/**
|
||||
@ -142,7 +143,7 @@ map_spl_path(void);
|
||||
* @return the path in file system encoding, or nullptr if mapping failed
|
||||
*/
|
||||
gcc_pure
|
||||
Path
|
||||
AllocatedPath
|
||||
map_spl_utf8_to_fs(const char *name);
|
||||
|
||||
#endif
|
||||
|
@ -35,7 +35,7 @@
|
||||
#include "Volume.hxx"
|
||||
#include "util/UriUtil.hxx"
|
||||
#include "util/Error.hxx"
|
||||
#include "fs/Path.hxx"
|
||||
#include "fs/AllocatedPath.hxx"
|
||||
#include "Stats.hxx"
|
||||
#include "Permission.hxx"
|
||||
#include "PlaylistFile.hxx"
|
||||
@ -117,7 +117,7 @@ handle_lsinfo(Client *client, int argc, char *argv[])
|
||||
if (memcmp(uri, "file:///", 8) == 0) {
|
||||
/* print information about an arbitrary local file */
|
||||
const char *path_utf8 = uri + 7;
|
||||
const Path path_fs = Path::FromUTF8(path_utf8);
|
||||
const auto path_fs = AllocatedPath::FromUTF8(path_utf8);
|
||||
|
||||
if (path_fs.IsNull()) {
|
||||
command_error(client, ACK_ERROR_NO_EXIST,
|
||||
|
@ -32,7 +32,7 @@
|
||||
#include "ConfigDefaults.hxx"
|
||||
#include "Idle.hxx"
|
||||
#include "fs/Limits.hxx"
|
||||
#include "fs/Path.hxx"
|
||||
#include "fs/AllocatedPath.hxx"
|
||||
#include "fs/Traits.hxx"
|
||||
#include "fs/Charset.hxx"
|
||||
#include "fs/FileSystem.hxx"
|
||||
@ -85,10 +85,10 @@ spl_valid_name(const char *name_utf8)
|
||||
strchr(name_utf8, '\r') == nullptr;
|
||||
}
|
||||
|
||||
static const Path &
|
||||
static const AllocatedPath &
|
||||
spl_map(Error &error)
|
||||
{
|
||||
const Path &path_fs = map_spl_path();
|
||||
const AllocatedPath &path_fs = map_spl_path();
|
||||
if (path_fs.IsNull())
|
||||
error.Set(playlist_domain, PLAYLIST_RESULT_DISABLED,
|
||||
"Stored playlists are disabled");
|
||||
@ -107,13 +107,13 @@ spl_check_name(const char *name_utf8, Error &error)
|
||||
return true;
|
||||
}
|
||||
|
||||
static Path
|
||||
static AllocatedPath
|
||||
spl_map_to_fs(const char *name_utf8, Error &error)
|
||||
{
|
||||
if (spl_map(error).IsNull() || !spl_check_name(name_utf8, error))
|
||||
return Path::Null();
|
||||
return AllocatedPath::Null();
|
||||
|
||||
Path path_fs = map_spl_utf8_to_fs(name_utf8);
|
||||
auto path_fs = map_spl_utf8_to_fs(name_utf8);
|
||||
if (path_fs.IsNull())
|
||||
error.Set(playlist_domain, PLAYLIST_RESULT_BAD_NAME,
|
||||
"Bad playlist name");
|
||||
@ -141,7 +141,8 @@ playlist_errno(Error &error)
|
||||
|
||||
static bool
|
||||
LoadPlaylistFileInfo(PlaylistInfo &info,
|
||||
const Path &parent_path_fs, const Path &name_fs)
|
||||
const AllocatedPath &parent_path_fs,
|
||||
const AllocatedPath &name_fs)
|
||||
{
|
||||
const char *name_fs_str = name_fs.c_str();
|
||||
size_t name_length = strlen(name_fs_str);
|
||||
@ -153,7 +154,7 @@ LoadPlaylistFileInfo(PlaylistInfo &info,
|
||||
if (!g_str_has_suffix(name_fs_str, PLAYLIST_FILE_SUFFIX))
|
||||
return false;
|
||||
|
||||
Path path_fs = Path::Build(parent_path_fs, name_fs);
|
||||
const auto path_fs = AllocatedPath::Build(parent_path_fs, name_fs);
|
||||
struct stat st;
|
||||
if (!StatFile(path_fs, st) || !S_ISREG(st.st_mode))
|
||||
return false;
|
||||
@ -175,7 +176,7 @@ ListPlaylistFiles(Error &error)
|
||||
{
|
||||
PlaylistVector list;
|
||||
|
||||
const Path &parent_path_fs = spl_map(error);
|
||||
const auto &parent_path_fs = spl_map(error);
|
||||
if (parent_path_fs.IsNull())
|
||||
return list;
|
||||
|
||||
@ -187,7 +188,7 @@ ListPlaylistFiles(Error &error)
|
||||
|
||||
PlaylistInfo info;
|
||||
while (reader.ReadEntry()) {
|
||||
const Path entry = reader.GetEntry();
|
||||
const auto entry = reader.GetEntry();
|
||||
if (LoadPlaylistFileInfo(info, parent_path_fs, entry))
|
||||
list.push_back(std::move(info));
|
||||
}
|
||||
@ -204,7 +205,7 @@ SavePlaylistFile(const PlaylistFileContents &contents, const char *utf8path,
|
||||
if (spl_map(error).IsNull())
|
||||
return false;
|
||||
|
||||
const Path path_fs = spl_map_to_fs(utf8path, error);
|
||||
const auto path_fs = spl_map_to_fs(utf8path, error);
|
||||
if (path_fs.IsNull())
|
||||
return false;
|
||||
|
||||
@ -229,7 +230,7 @@ LoadPlaylistFile(const char *utf8path, Error &error)
|
||||
if (spl_map(error).IsNull())
|
||||
return contents;
|
||||
|
||||
const Path path_fs = spl_map_to_fs(utf8path, error);
|
||||
const auto path_fs = spl_map_to_fs(utf8path, error);
|
||||
if (path_fs.IsNull())
|
||||
return contents;
|
||||
|
||||
@ -310,7 +311,7 @@ spl_clear(const char *utf8path, Error &error)
|
||||
if (spl_map(error).IsNull())
|
||||
return false;
|
||||
|
||||
const Path path_fs = spl_map_to_fs(utf8path, error);
|
||||
const auto path_fs = spl_map_to_fs(utf8path, error);
|
||||
if (path_fs.IsNull())
|
||||
return false;
|
||||
|
||||
@ -329,7 +330,7 @@ spl_clear(const char *utf8path, Error &error)
|
||||
bool
|
||||
spl_delete(const char *name_utf8, Error &error)
|
||||
{
|
||||
const Path path_fs = spl_map_to_fs(name_utf8, error);
|
||||
const auto path_fs = spl_map_to_fs(name_utf8, error);
|
||||
if (path_fs.IsNull())
|
||||
return false;
|
||||
|
||||
@ -369,7 +370,7 @@ spl_append_song(const char *utf8path, Song *song, Error &error)
|
||||
if (spl_map(error).IsNull())
|
||||
return false;
|
||||
|
||||
const Path path_fs = spl_map_to_fs(utf8path, error);
|
||||
const auto path_fs = spl_map_to_fs(utf8path, error);
|
||||
if (path_fs.IsNull())
|
||||
return false;
|
||||
|
||||
@ -425,7 +426,7 @@ spl_append_uri(const char *url, const char *utf8file, Error &error)
|
||||
}
|
||||
|
||||
static bool
|
||||
spl_rename_internal(const Path &from_path_fs, const Path &to_path_fs,
|
||||
spl_rename_internal(Path from_path_fs, Path to_path_fs,
|
||||
Error &error)
|
||||
{
|
||||
if (!FileExists(from_path_fs)) {
|
||||
@ -455,11 +456,11 @@ spl_rename(const char *utf8from, const char *utf8to, Error &error)
|
||||
if (spl_map(error).IsNull())
|
||||
return false;
|
||||
|
||||
Path from_path_fs = spl_map_to_fs(utf8from, error);
|
||||
const auto from_path_fs = spl_map_to_fs(utf8from, error);
|
||||
if (from_path_fs.IsNull())
|
||||
return false;
|
||||
|
||||
Path to_path_fs = spl_map_to_fs(utf8to, error);
|
||||
const auto to_path_fs = spl_map_to_fs(utf8to, error);
|
||||
if (to_path_fs.IsNull())
|
||||
return false;
|
||||
|
||||
|
@ -22,7 +22,7 @@
|
||||
#include "PlaylistFile.hxx"
|
||||
#include "PlaylistRegistry.hxx"
|
||||
#include "Mapper.hxx"
|
||||
#include "fs/Path.hxx"
|
||||
#include "fs/AllocatedPath.hxx"
|
||||
#include "util/UriUtil.hxx"
|
||||
|
||||
#include <assert.h>
|
||||
@ -49,15 +49,16 @@ playlist_open_in_playlist_dir(const char *uri, Mutex &mutex, Cond &cond,
|
||||
{
|
||||
assert(spl_valid_name(uri));
|
||||
|
||||
const Path &playlist_directory_fs = map_spl_path();
|
||||
const auto &playlist_directory_fs = map_spl_path();
|
||||
if (playlist_directory_fs.IsNull())
|
||||
return nullptr;
|
||||
|
||||
const Path uri_fs = Path::FromUTF8(uri);
|
||||
const auto uri_fs = AllocatedPath::FromUTF8(uri);
|
||||
if (uri_fs.IsNull())
|
||||
return nullptr;
|
||||
|
||||
const Path path_fs = Path::Build(playlist_directory_fs, uri_fs);
|
||||
const auto path_fs =
|
||||
AllocatedPath::Build(playlist_directory_fs, uri_fs);
|
||||
assert(!path_fs.IsNull());
|
||||
|
||||
return playlist_open_path(path_fs.c_str(), mutex, cond, is_r);
|
||||
@ -72,7 +73,7 @@ playlist_open_in_music_dir(const char *uri, Mutex &mutex, Cond &cond,
|
||||
{
|
||||
assert(uri_safe_local(uri));
|
||||
|
||||
Path path = map_uri_fs(uri);
|
||||
const auto path = map_uri_fs(uri);
|
||||
if (path.IsNull())
|
||||
return nullptr;
|
||||
|
||||
|
@ -25,7 +25,7 @@
|
||||
#include "Song.hxx"
|
||||
#include "Mapper.hxx"
|
||||
#include "Idle.hxx"
|
||||
#include "fs/Path.hxx"
|
||||
#include "fs/AllocatedPath.hxx"
|
||||
#include "fs/Traits.hxx"
|
||||
#include "fs/FileSystem.hxx"
|
||||
#include "util/UriUtil.hxx"
|
||||
@ -40,12 +40,12 @@ void
|
||||
playlist_print_song(FILE *file, const Song *song)
|
||||
{
|
||||
if (playlist_saveAbsolutePaths && song->IsInDatabase()) {
|
||||
const Path path = map_song_fs(song);
|
||||
const auto path = map_song_fs(song);
|
||||
if (!path.IsNull())
|
||||
fprintf(file, "%s\n", path.c_str());
|
||||
} else {
|
||||
const auto uri_utf8 = song->GetURI();
|
||||
const Path uri_fs = Path::FromUTF8(uri_utf8.c_str());
|
||||
const auto uri_fs = AllocatedPath::FromUTF8(uri_utf8.c_str());
|
||||
|
||||
if (!uri_fs.IsNull())
|
||||
fprintf(file, "%s\n", uri_fs.c_str());
|
||||
@ -55,10 +55,10 @@ playlist_print_song(FILE *file, const Song *song)
|
||||
void
|
||||
playlist_print_uri(FILE *file, const char *uri)
|
||||
{
|
||||
Path path = playlist_saveAbsolutePaths && !uri_has_scheme(uri) &&
|
||||
auto path = playlist_saveAbsolutePaths && !uri_has_scheme(uri) &&
|
||||
!PathTraits::IsAbsoluteUTF8(uri)
|
||||
? map_uri_fs(uri)
|
||||
: Path::FromUTF8(uri);
|
||||
: AllocatedPath::FromUTF8(uri);
|
||||
|
||||
if (!path.IsNull())
|
||||
fprintf(file, "%s\n", path.c_str());
|
||||
@ -73,7 +73,7 @@ spl_save_queue(const char *name_utf8, const struct queue *queue)
|
||||
if (!spl_valid_name(name_utf8))
|
||||
return PLAYLIST_RESULT_BAD_NAME;
|
||||
|
||||
const Path path_fs = map_spl_utf8_to_fs(name_utf8);
|
||||
const auto path_fs = map_spl_utf8_to_fs(name_utf8);
|
||||
if (path_fs.IsNull())
|
||||
return PLAYLIST_RESULT_BAD_NAME;
|
||||
|
||||
|
@ -24,7 +24,7 @@
|
||||
#include "DatabaseGlue.hxx"
|
||||
#include "ls.hxx"
|
||||
#include "tag/Tag.hxx"
|
||||
#include "fs/Path.hxx"
|
||||
#include "fs/AllocatedPath.hxx"
|
||||
#include "fs/Traits.hxx"
|
||||
#include "util/UriUtil.hxx"
|
||||
#include "util/Error.hxx"
|
||||
@ -64,7 +64,7 @@ apply_song_metadata(Song *dest, const Song *src)
|
||||
return dest;
|
||||
|
||||
if (dest->IsInDatabase()) {
|
||||
const Path &path_fs = map_song_fs(dest);
|
||||
const auto path_fs = map_song_fs(dest);
|
||||
if (path_fs.IsNull())
|
||||
return dest;
|
||||
|
||||
|
@ -33,7 +33,7 @@
|
||||
#include "ls.hxx"
|
||||
#include "util/UriUtil.hxx"
|
||||
#include "util/Error.hxx"
|
||||
#include "fs/Path.hxx"
|
||||
#include "fs/AllocatedPath.hxx"
|
||||
|
||||
#include <limits>
|
||||
|
||||
@ -47,7 +47,7 @@ handle_add(Client *client, gcc_unused int argc, char *argv[])
|
||||
|
||||
if (memcmp(uri, "file:///", 8) == 0) {
|
||||
const char *path_utf8 = uri + 7;
|
||||
const Path path_fs = Path::FromUTF8(path_utf8);
|
||||
const auto path_fs = AllocatedPath::FromUTF8(path_utf8);
|
||||
|
||||
if (path_fs.IsNull()) {
|
||||
command_error(client, ACK_ERROR_NO_EXIST,
|
||||
@ -90,7 +90,7 @@ handle_addid(Client *client, int argc, char *argv[])
|
||||
|
||||
if (memcmp(uri, "file:///", 8) == 0) {
|
||||
const char *path_utf8 = uri + 7;
|
||||
const Path path_fs = Path::FromUTF8(path_utf8);
|
||||
const auto path_fs = AllocatedPath::FromUTF8(path_utf8);
|
||||
|
||||
if (path_fs.IsNull()) {
|
||||
command_error(client, ACK_ERROR_NO_EXIST,
|
||||
|
@ -23,7 +23,7 @@
|
||||
#include "util/Error.hxx"
|
||||
#include "Directory.hxx"
|
||||
#include "Mapper.hxx"
|
||||
#include "fs/Path.hxx"
|
||||
#include "fs/AllocatedPath.hxx"
|
||||
#include "fs/Traits.hxx"
|
||||
#include "fs/FileSystem.hxx"
|
||||
#include "InputStream.hxx"
|
||||
@ -99,7 +99,7 @@ Song::UpdateFile()
|
||||
if (plugin == NULL)
|
||||
return false;
|
||||
|
||||
const Path path_fs = map_song_fs(this);
|
||||
const auto path_fs = map_song_fs(this);
|
||||
if (path_fs.IsNull())
|
||||
return false;
|
||||
|
||||
|
@ -33,7 +33,7 @@
|
||||
|
||||
static constexpr Domain state_file_domain("state_file");
|
||||
|
||||
StateFile::StateFile(Path &&_path,
|
||||
StateFile::StateFile(AllocatedPath &&_path,
|
||||
Partition &_partition, EventLoop &_loop)
|
||||
:TimeoutMonitor(_loop),
|
||||
path(std::move(_path)), path_utf8(path.ToUTF8()),
|
||||
|
@ -21,7 +21,7 @@
|
||||
#define MPD_STATE_FILE_HXX
|
||||
|
||||
#include "event/TimeoutMonitor.hxx"
|
||||
#include "fs/Path.hxx"
|
||||
#include "fs/AllocatedPath.hxx"
|
||||
#include "Compiler.h"
|
||||
|
||||
#include <string>
|
||||
@ -29,7 +29,7 @@
|
||||
struct Partition;
|
||||
|
||||
class StateFile final : private TimeoutMonitor {
|
||||
Path path;
|
||||
AllocatedPath path;
|
||||
std::string path_utf8;
|
||||
|
||||
Partition &partition;
|
||||
@ -42,7 +42,7 @@ class StateFile final : private TimeoutMonitor {
|
||||
prev_playlist_version;
|
||||
|
||||
public:
|
||||
StateFile(Path &&path, Partition &partition, EventLoop &loop);
|
||||
StateFile(AllocatedPath &&path, Partition &partition, EventLoop &loop);
|
||||
|
||||
void Read();
|
||||
void Write();
|
||||
|
@ -107,13 +107,11 @@ sticker_prepare(const char *sql, Error &error)
|
||||
}
|
||||
|
||||
bool
|
||||
sticker_global_init(Path &&path, Error &error)
|
||||
sticker_global_init(Path path, Error &error)
|
||||
{
|
||||
int ret;
|
||||
assert(!path.IsNull());
|
||||
|
||||
if (path.IsNull())
|
||||
/* not configured */
|
||||
return true;
|
||||
int ret;
|
||||
|
||||
/* open/create the sqlite database */
|
||||
|
||||
|
@ -58,7 +58,7 @@ struct sticker;
|
||||
* @return true on success, false on error
|
||||
*/
|
||||
bool
|
||||
sticker_global_init(Path &&path, Error &error);
|
||||
sticker_global_init(Path path, Error &error);
|
||||
|
||||
/**
|
||||
* Close the sticker database.
|
||||
|
@ -27,7 +27,7 @@
|
||||
#include <assert.h>
|
||||
#include <string.h>
|
||||
|
||||
TextFile::TextFile(const Path &path_fs)
|
||||
TextFile::TextFile(Path path_fs)
|
||||
:file(FOpen(path_fs, FOpenMode::ReadText)),
|
||||
buffer(g_string_sized_new(step)) {}
|
||||
|
||||
|
@ -36,7 +36,7 @@ class TextFile {
|
||||
GString *const buffer;
|
||||
|
||||
public:
|
||||
TextFile(const Path &path_fs);
|
||||
TextFile(Path path_fs);
|
||||
|
||||
TextFile(const TextFile &other) = delete;
|
||||
|
||||
|
@ -25,7 +25,7 @@
|
||||
#include "Directory.hxx"
|
||||
#include "Song.hxx"
|
||||
#include "Mapper.hxx"
|
||||
#include "fs/Path.hxx"
|
||||
#include "fs/AllocatedPath.hxx"
|
||||
#include "ArchiveList.hxx"
|
||||
#include "ArchivePlugin.hxx"
|
||||
#include "ArchiveFile.hxx"
|
||||
@ -101,7 +101,7 @@ update_archive_file2(Directory *parent, const char *name,
|
||||
changed since - don't consider updating it */
|
||||
return;
|
||||
|
||||
const Path path_fs = map_directory_child_fs(parent, name);
|
||||
const auto path_fs = map_directory_child_fs(parent, name);
|
||||
|
||||
/* open archive */
|
||||
Error error;
|
||||
|
@ -27,7 +27,7 @@
|
||||
#include "Song.hxx"
|
||||
#include "DecoderPlugin.hxx"
|
||||
#include "Mapper.hxx"
|
||||
#include "fs/Path.hxx"
|
||||
#include "fs/AllocatedPath.hxx"
|
||||
#include "tag/TagHandler.hxx"
|
||||
#include "tag/TagBuilder.hxx"
|
||||
#include "Log.hxx"
|
||||
@ -84,7 +84,7 @@ update_container_file(Directory *directory,
|
||||
contdir->device = DEVICE_CONTAINER;
|
||||
db_unlock();
|
||||
|
||||
const Path pathname = map_directory_child_fs(directory, name);
|
||||
const auto pathname = map_directory_child_fs(directory, name);
|
||||
|
||||
char *vtrack;
|
||||
unsigned int tnum = 0;
|
||||
@ -95,7 +95,7 @@ update_container_file(Directory *directory,
|
||||
// shouldn't be necessary but it's there..
|
||||
song->mtime = st->st_mtime;
|
||||
|
||||
const Path child_path_fs =
|
||||
const auto child_path_fs =
|
||||
map_directory_child_fs(contdir, vtrack);
|
||||
|
||||
decoder_plugin_scan_file(plugin, child_path_fs.c_str(),
|
||||
|
@ -22,7 +22,7 @@
|
||||
#include "src/UpdateDomain.hxx"
|
||||
#include "Directory.hxx"
|
||||
#include "Mapper.hxx"
|
||||
#include "fs/Path.hxx"
|
||||
#include "fs/AllocatedPath.hxx"
|
||||
#include "fs/FileSystem.hxx"
|
||||
#include "Log.hxx"
|
||||
|
||||
@ -32,7 +32,7 @@
|
||||
int
|
||||
stat_directory(const Directory *directory, struct stat *st)
|
||||
{
|
||||
const Path path_fs = map_directory_fs(directory);
|
||||
const auto path_fs = map_directory_fs(directory);
|
||||
if (path_fs.IsNull())
|
||||
return -1;
|
||||
|
||||
@ -51,7 +51,7 @@ int
|
||||
stat_directory_child(const Directory *parent, const char *name,
|
||||
struct stat *st)
|
||||
{
|
||||
const Path path_fs = map_directory_child_fs(parent, name);
|
||||
const auto path_fs = map_directory_child_fs(parent, name);
|
||||
if (path_fs.IsNull())
|
||||
return -1;
|
||||
|
||||
@ -69,7 +69,7 @@ stat_directory_child(const Directory *parent, const char *name,
|
||||
bool
|
||||
directory_exists(const Directory *directory)
|
||||
{
|
||||
const Path path_fs = map_directory_fs(directory);
|
||||
const auto path_fs = map_directory_fs(directory);
|
||||
if (path_fs.IsNull())
|
||||
/* invalid path: cannot exist */
|
||||
return false;
|
||||
@ -84,7 +84,7 @@ bool
|
||||
directory_child_is_regular(const Directory *directory,
|
||||
const char *name_utf8)
|
||||
{
|
||||
const Path path_fs = map_directory_child_fs(directory, name_utf8);
|
||||
const auto path_fs = map_directory_child_fs(directory, name_utf8);
|
||||
if (path_fs.IsNull())
|
||||
return false;
|
||||
|
||||
@ -102,7 +102,7 @@ directory_child_access(const Directory *directory,
|
||||
(void)mode;
|
||||
return true;
|
||||
#else
|
||||
const Path path = map_directory_child_fs(directory, name);
|
||||
const auto path = map_directory_child_fs(directory, name);
|
||||
if (path.IsNull())
|
||||
/* something went wrong, but that isn't a permission
|
||||
problem */
|
||||
|
@ -34,7 +34,7 @@
|
||||
#include "ExcludeList.hxx"
|
||||
#include "ConfigGlobal.hxx"
|
||||
#include "ConfigOption.hxx"
|
||||
#include "fs/Path.hxx"
|
||||
#include "fs/AllocatedPath.hxx"
|
||||
#include "fs/Traits.hxx"
|
||||
#include "fs/FileSystem.hxx"
|
||||
#include "fs/DirectoryReader.hxx"
|
||||
@ -102,7 +102,7 @@ remove_excluded_from_directory(Directory *directory,
|
||||
|
||||
Directory *child, *n;
|
||||
directory_for_each_child_safe(child, n, directory) {
|
||||
const Path name_fs = Path::FromUTF8(child->GetName());
|
||||
const auto name_fs = AllocatedPath::FromUTF8(child->GetName());
|
||||
|
||||
if (name_fs.IsNull() || exclude_list.Check(name_fs)) {
|
||||
delete_directory(child);
|
||||
@ -114,7 +114,7 @@ remove_excluded_from_directory(Directory *directory,
|
||||
directory_for_each_song_safe(song, ns, directory) {
|
||||
assert(song->parent == directory);
|
||||
|
||||
const Path name_fs = Path::FromUTF8(song->uri);
|
||||
const auto name_fs = AllocatedPath::FromUTF8(song->uri);
|
||||
if (name_fs.IsNull() || exclude_list.Check(name_fs)) {
|
||||
delete_song(directory, song);
|
||||
modified = true;
|
||||
@ -141,7 +141,7 @@ purge_deleted_from_directory(Directory *directory)
|
||||
|
||||
Song *song, *ns;
|
||||
directory_for_each_song_safe(song, ns, directory) {
|
||||
const Path path = map_song_fs(song);
|
||||
const auto path = map_song_fs(song);
|
||||
if (path.IsNull() || !FileExists(path)) {
|
||||
db_lock();
|
||||
delete_song(directory, song);
|
||||
@ -264,7 +264,7 @@ update_directory_child(Directory *directory,
|
||||
|
||||
/* we don't look at "." / ".." nor files with newlines in their name */
|
||||
gcc_pure
|
||||
static bool skip_path(const Path &path_fs)
|
||||
static bool skip_path(Path path_fs)
|
||||
{
|
||||
const char *path = path_fs.c_str();
|
||||
return (path[0] == '.' && path[1] == 0) ||
|
||||
@ -277,11 +277,11 @@ static bool
|
||||
skip_symlink(const Directory *directory, const char *utf8_name)
|
||||
{
|
||||
#ifndef WIN32
|
||||
const Path path_fs = map_directory_child_fs(directory, utf8_name);
|
||||
const auto path_fs = map_directory_child_fs(directory, utf8_name);
|
||||
if (path_fs.IsNull())
|
||||
return true;
|
||||
|
||||
const Path target = ReadLink(path_fs);
|
||||
const auto target = ReadLink(path_fs);
|
||||
if (target.IsNull())
|
||||
/* don't skip if this is not a symlink */
|
||||
return errno != EINVAL;
|
||||
@ -345,7 +345,7 @@ update_directory(Directory *directory, const struct stat *st)
|
||||
|
||||
directory_set_stat(directory, st);
|
||||
|
||||
const Path path_fs = map_directory_fs(directory);
|
||||
const auto path_fs = map_directory_fs(directory);
|
||||
if (path_fs.IsNull())
|
||||
return false;
|
||||
|
||||
@ -360,7 +360,7 @@ update_directory(Directory *directory, const struct stat *st)
|
||||
}
|
||||
|
||||
ExcludeList exclude_list;
|
||||
exclude_list.LoadFile(Path::Build(path_fs, ".mpdignore"));
|
||||
exclude_list.LoadFile(AllocatedPath::Build(path_fs, ".mpdignore"));
|
||||
|
||||
if (!exclude_list.IsEmpty())
|
||||
remove_excluded_from_directory(directory, exclude_list);
|
||||
@ -371,7 +371,7 @@ update_directory(Directory *directory, const struct stat *st)
|
||||
std::string utf8;
|
||||
struct stat st2;
|
||||
|
||||
const Path entry = reader.GetEntry();
|
||||
const auto entry = reader.GetEntry();
|
||||
|
||||
if (skip_path(entry) || exclude_list.Check(entry))
|
||||
continue;
|
||||
|
@ -76,7 +76,7 @@ SimpleDatabase::Check(Error &error) const
|
||||
/* If the file doesn't exist, we can't check if we can write
|
||||
* it, so we are going to try to get the directory path, and
|
||||
* see if we can write a file in that */
|
||||
const Path dirPath = path.GetDirectoryName();
|
||||
const auto dirPath = path.GetDirectoryName();
|
||||
|
||||
/* Check that the parent part of the path is a directory */
|
||||
struct stat st;
|
||||
|
@ -21,7 +21,7 @@
|
||||
#define MPD_SIMPLE_DATABASE_PLUGIN_HXX
|
||||
|
||||
#include "DatabasePlugin.hxx"
|
||||
#include "fs/Path.hxx"
|
||||
#include "fs/AllocatedPath.hxx"
|
||||
#include "Compiler.h"
|
||||
|
||||
#include <cassert>
|
||||
@ -31,7 +31,7 @@
|
||||
struct Directory;
|
||||
|
||||
class SimpleDatabase : public Database {
|
||||
Path path;
|
||||
AllocatedPath path;
|
||||
std::string path_utf8;
|
||||
|
||||
Directory *root;
|
||||
@ -43,7 +43,7 @@ class SimpleDatabase : public Database {
|
||||
#endif
|
||||
|
||||
SimpleDatabase()
|
||||
:path(Path::Null()) {}
|
||||
:path(AllocatedPath::Null()) {}
|
||||
|
||||
public:
|
||||
gcc_pure
|
||||
|
@ -23,7 +23,7 @@
|
||||
#include "tag/TagHandler.hxx"
|
||||
#include "util/Error.hxx"
|
||||
#include "util/Domain.hxx"
|
||||
#include "fs/Path.hxx"
|
||||
#include "fs/AllocatedPath.hxx"
|
||||
#include "fs/FileSystem.hxx"
|
||||
#include "system/FatalError.hxx"
|
||||
#include "Log.hxx"
|
||||
@ -40,7 +40,8 @@ static bool
|
||||
wildmidi_init(const config_param ¶m)
|
||||
{
|
||||
Error error;
|
||||
const Path path = param.GetBlockPath("config_file",
|
||||
const AllocatedPath path =
|
||||
param.GetBlockPath("config_file",
|
||||
"/etc/timidity/timidity.cfg",
|
||||
error);
|
||||
if (path.IsNull())
|
||||
|
113
src/fs/AllocatedPath.cxx
Normal file
113
src/fs/AllocatedPath.cxx
Normal file
@ -0,0 +1,113 @@
|
||||
/*
|
||||
* Copyright (C) 2003-2013 The Music Player Daemon Project
|
||||
* http://www.musicpd.org
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License along
|
||||
* with this program; if not, write to the Free Software Foundation, Inc.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
*/
|
||||
|
||||
#include "config.h"
|
||||
#include "AllocatedPath.hxx"
|
||||
#include "Domain.hxx"
|
||||
#include "Charset.hxx"
|
||||
#include "util/Error.hxx"
|
||||
#include "Compiler.h"
|
||||
|
||||
#include <glib.h>
|
||||
|
||||
#include <assert.h>
|
||||
#include <string.h>
|
||||
|
||||
inline AllocatedPath::AllocatedPath(Donate, pointer _value)
|
||||
:value(_value) {
|
||||
g_free(_value);
|
||||
}
|
||||
|
||||
/* no inlining, please */
|
||||
AllocatedPath::~AllocatedPath() {}
|
||||
|
||||
AllocatedPath
|
||||
AllocatedPath::Build(const_pointer a, const_pointer b)
|
||||
{
|
||||
return AllocatedPath(Donate(), g_build_filename(a, b, nullptr));
|
||||
}
|
||||
|
||||
AllocatedPath
|
||||
AllocatedPath::FromUTF8(const char *path_utf8)
|
||||
{
|
||||
return AllocatedPath(Donate(), ::PathFromUTF8(path_utf8));
|
||||
}
|
||||
|
||||
AllocatedPath
|
||||
AllocatedPath::FromUTF8(const char *path_utf8, Error &error)
|
||||
{
|
||||
AllocatedPath path = FromUTF8(path_utf8);
|
||||
if (path.IsNull())
|
||||
error.Format(path_domain,
|
||||
"Failed to convert to file system charset: %s",
|
||||
path_utf8);
|
||||
|
||||
return path;
|
||||
}
|
||||
|
||||
AllocatedPath
|
||||
AllocatedPath::GetDirectoryName() const
|
||||
{
|
||||
return AllocatedPath(Donate(), g_path_get_dirname(c_str()));
|
||||
}
|
||||
|
||||
std::string
|
||||
AllocatedPath::ToUTF8() const
|
||||
{
|
||||
return ::PathToUTF8(c_str());
|
||||
}
|
||||
|
||||
const char *
|
||||
AllocatedPath::RelativeFS(const char *other_fs) const
|
||||
{
|
||||
const size_t l = length();
|
||||
if (memcmp(data(), other_fs, l) != 0)
|
||||
return nullptr;
|
||||
|
||||
other_fs += l;
|
||||
if (*other_fs != 0) {
|
||||
if (!PathTraits::IsSeparatorFS(*other_fs))
|
||||
/* mismatch */
|
||||
return nullptr;
|
||||
|
||||
/* skip remaining path separators */
|
||||
do {
|
||||
++other_fs;
|
||||
} while (PathTraits::IsSeparatorFS(*other_fs));
|
||||
}
|
||||
|
||||
return other_fs;
|
||||
}
|
||||
|
||||
void
|
||||
AllocatedPath::ChopSeparators()
|
||||
{
|
||||
size_t l = length();
|
||||
const char *p = data();
|
||||
|
||||
while (l >= 2 && PathTraits::IsSeparatorFS(p[l - 1])) {
|
||||
--l;
|
||||
|
||||
#if GCC_CHECK_VERSION(4,7) && !defined(__clang__)
|
||||
value.pop_back();
|
||||
#else
|
||||
value.erase(value.end() - 1, value.end());
|
||||
#endif
|
||||
}
|
||||
}
|
226
src/fs/AllocatedPath.hxx
Normal file
226
src/fs/AllocatedPath.hxx
Normal file
@ -0,0 +1,226 @@
|
||||
/*
|
||||
* Copyright (C) 2003-2013 The Music Player Daemon Project
|
||||
* http://www.musicpd.org
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License along
|
||||
* with this program; if not, write to the Free Software Foundation, Inc.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
*/
|
||||
|
||||
#ifndef MPD_FS_ALLOCATED_PATH_HXX
|
||||
#define MPD_FS_ALLOCATED_PATH_HXX
|
||||
|
||||
#include "check.h"
|
||||
#include "Compiler.h"
|
||||
#include "Traits.hxx"
|
||||
#include "Path.hxx"
|
||||
|
||||
#ifdef WIN32
|
||||
#include <glib.h>
|
||||
#endif
|
||||
|
||||
#include <utility>
|
||||
#include <string>
|
||||
|
||||
#include <assert.h>
|
||||
|
||||
class Error;
|
||||
|
||||
/**
|
||||
* A path name in the native file system character set.
|
||||
*
|
||||
* This class manages the memory chunk where this path string is
|
||||
* stored.
|
||||
*/
|
||||
class AllocatedPath {
|
||||
typedef std::string string;
|
||||
|
||||
typedef PathTraits::value_type value_type;
|
||||
typedef PathTraits::pointer pointer;
|
||||
typedef PathTraits::const_pointer const_pointer;
|
||||
|
||||
string value;
|
||||
|
||||
struct Donate {};
|
||||
|
||||
/**
|
||||
* Donate the allocated pointer to a new #AllocatedPath object.
|
||||
*/
|
||||
AllocatedPath(Donate, pointer _value);
|
||||
|
||||
AllocatedPath(const_pointer _value):value(_value) {}
|
||||
|
||||
public:
|
||||
/**
|
||||
* Copy a #AllocatedPath object.
|
||||
*/
|
||||
AllocatedPath(const AllocatedPath &) = default;
|
||||
|
||||
/**
|
||||
* Move a #AllocatedPath object.
|
||||
*/
|
||||
AllocatedPath(AllocatedPath &&other):value(std::move(other.value)) {}
|
||||
|
||||
~AllocatedPath();
|
||||
|
||||
/**
|
||||
* Return a "nulled" instance. Its IsNull() method will
|
||||
* return true. Such an object must not be used.
|
||||
*
|
||||
* @see IsNull()
|
||||
*/
|
||||
gcc_const
|
||||
static AllocatedPath Null() {
|
||||
return AllocatedPath("");
|
||||
}
|
||||
|
||||
gcc_pure
|
||||
operator Path() const {
|
||||
return Path::FromFS(c_str());
|
||||
}
|
||||
|
||||
/**
|
||||
* Join two path components with the path separator.
|
||||
*/
|
||||
gcc_pure gcc_nonnull_all
|
||||
static AllocatedPath Build(const_pointer a, const_pointer b);
|
||||
|
||||
gcc_pure gcc_nonnull_all
|
||||
static AllocatedPath Build(const_pointer a, const AllocatedPath &b) {
|
||||
return Build(a, b.c_str());
|
||||
}
|
||||
|
||||
gcc_pure gcc_nonnull_all
|
||||
static AllocatedPath Build(const AllocatedPath &a, const_pointer b) {
|
||||
return Build(a.c_str(), b);
|
||||
}
|
||||
|
||||
gcc_pure
|
||||
static AllocatedPath Build(const AllocatedPath &a,
|
||||
const AllocatedPath &b) {
|
||||
return Build(a.c_str(), b.c_str());
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert a C string that is already in the filesystem
|
||||
* character set to a #Path instance.
|
||||
*/
|
||||
gcc_pure
|
||||
static AllocatedPath FromFS(const_pointer fs) {
|
||||
return AllocatedPath(fs);
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert a UTF-8 C string to a #AllocatedPath instance.
|
||||
* Returns return a "nulled" instance on error.
|
||||
*/
|
||||
gcc_pure gcc_nonnull_all
|
||||
static AllocatedPath FromUTF8(const char *path_utf8);
|
||||
|
||||
gcc_pure gcc_nonnull_all
|
||||
static AllocatedPath FromUTF8(const char *path_utf8, Error &error);
|
||||
|
||||
/**
|
||||
* Copy a #AllocatedPath object.
|
||||
*/
|
||||
AllocatedPath &operator=(const AllocatedPath &) = default;
|
||||
|
||||
/**
|
||||
* Move a #AllocatedPath object.
|
||||
*/
|
||||
AllocatedPath &operator=(AllocatedPath &&other) {
|
||||
value = std::move(other.value);
|
||||
return *this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if this is a "nulled" instance. A "nulled" instance
|
||||
* must not be used.
|
||||
*/
|
||||
bool IsNull() const {
|
||||
return value.empty();
|
||||
}
|
||||
|
||||
/**
|
||||
* Clear this object's value, make it "nulled".
|
||||
*
|
||||
* @see IsNull()
|
||||
*/
|
||||
void SetNull() {
|
||||
value.clear();
|
||||
}
|
||||
|
||||
/**
|
||||
* @return the length of this string in number of "value_type"
|
||||
* elements (which may not be the number of characters).
|
||||
*/
|
||||
gcc_pure
|
||||
size_t length() const {
|
||||
return value.length();
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the value as a const C string. The returned
|
||||
* pointer is invalidated whenever the value of life of this
|
||||
* instance ends.
|
||||
*/
|
||||
gcc_pure
|
||||
const_pointer c_str() const {
|
||||
return value.c_str();
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a pointer to the raw value, not necessarily
|
||||
* null-terminated.
|
||||
*/
|
||||
gcc_pure
|
||||
const_pointer data() const {
|
||||
return value.data();
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert the path to UTF-8.
|
||||
* Returns empty string on error or if this instance is "nulled"
|
||||
* (#IsNull returns true).
|
||||
*/
|
||||
gcc_pure
|
||||
std::string ToUTF8() const;
|
||||
|
||||
/**
|
||||
* Gets directory name of this path.
|
||||
* Returns a "nulled" instance on error.
|
||||
*/
|
||||
gcc_pure
|
||||
AllocatedPath GetDirectoryName() const;
|
||||
|
||||
/**
|
||||
* Determine the relative part of the given path to this
|
||||
* object, not including the directory separator. Returns an
|
||||
* empty string if the given path equals this object or
|
||||
* nullptr on mismatch.
|
||||
*/
|
||||
gcc_pure
|
||||
const char *RelativeFS(const char *other_fs) const;
|
||||
|
||||
/**
|
||||
* Chop trailing directory separators.
|
||||
*/
|
||||
void ChopSeparators();
|
||||
|
||||
gcc_pure
|
||||
bool IsAbsolute() {
|
||||
return PathTraits::IsAbsoluteFS(c_str());
|
||||
}
|
||||
};
|
||||
|
||||
#endif
|
@ -21,7 +21,7 @@
|
||||
#define MPD_FS_DIRECTORY_READER_HXX
|
||||
|
||||
#include "check.h"
|
||||
#include "Path.hxx"
|
||||
#include "AllocatedPath.hxx"
|
||||
|
||||
#include <dirent.h>
|
||||
|
||||
@ -35,7 +35,7 @@ public:
|
||||
/**
|
||||
* Creates new directory reader for the specified #dir.
|
||||
*/
|
||||
explicit DirectoryReader(const Path &dir)
|
||||
explicit DirectoryReader(Path dir)
|
||||
: dirp(opendir(dir.c_str())),
|
||||
ent(nullptr) {
|
||||
}
|
||||
@ -78,9 +78,9 @@ public:
|
||||
/**
|
||||
* Extracts directory entry that was previously read by #ReadEntry.
|
||||
*/
|
||||
Path GetEntry() const {
|
||||
AllocatedPath GetEntry() const {
|
||||
assert(HasEntry());
|
||||
return Path::FromFS(ent->d_name);
|
||||
return AllocatedPath::FromFS(ent->d_name);
|
||||
}
|
||||
};
|
||||
|
||||
|
@ -19,26 +19,28 @@
|
||||
|
||||
#include "config.h"
|
||||
#include "FileSystem.hxx"
|
||||
#include "AllocatedPath.hxx"
|
||||
#include "Limits.hxx"
|
||||
|
||||
#include <errno.h>
|
||||
|
||||
Path ReadLink(const Path &path)
|
||||
AllocatedPath
|
||||
ReadLink(Path path)
|
||||
{
|
||||
#ifdef WIN32
|
||||
(void)path;
|
||||
errno = EINVAL;
|
||||
return Path::Null();
|
||||
return AllocatedPath::Null();
|
||||
#else
|
||||
char buffer[MPD_PATH_MAX];
|
||||
ssize_t size = readlink(path.c_str(), buffer, MPD_PATH_MAX);
|
||||
if (size < 0)
|
||||
return Path::Null();
|
||||
return AllocatedPath::Null();
|
||||
if (size_t(size) >= MPD_PATH_MAX) {
|
||||
errno = ENOMEM;
|
||||
return Path::Null();
|
||||
return AllocatedPath::Null();
|
||||
}
|
||||
buffer[size] = '\0';
|
||||
return Path::FromFS(buffer);
|
||||
return AllocatedPath::FromFS(buffer);
|
||||
#endif
|
||||
}
|
||||
|
@ -31,6 +31,8 @@
|
||||
#include <assert.h>
|
||||
#include <stdio.h>
|
||||
|
||||
class AllocatedPath;
|
||||
|
||||
namespace FOpenMode {
|
||||
/**
|
||||
* Open mode for reading text files.
|
||||
@ -67,7 +69,7 @@ namespace FOpenMode {
|
||||
* Wrapper for fopen() that uses #Path names.
|
||||
*/
|
||||
static inline FILE *
|
||||
FOpen(const Path &file, PathTraits::const_pointer mode)
|
||||
FOpen(Path file, PathTraits::const_pointer mode)
|
||||
{
|
||||
return fopen(file.c_str(), mode);
|
||||
}
|
||||
@ -75,7 +77,8 @@ FOpen(const Path &file, PathTraits::const_pointer mode)
|
||||
/**
|
||||
* Wrapper for open_cloexec() that uses #Path names.
|
||||
*/
|
||||
static inline int OpenFile(const Path &file, int flags, int mode)
|
||||
static inline int
|
||||
OpenFile(Path file, int flags, int mode)
|
||||
{
|
||||
return open_cloexec(file.c_str(), flags, mode);
|
||||
}
|
||||
@ -83,7 +86,8 @@ static inline int OpenFile(const Path &file, int flags, int mode)
|
||||
/**
|
||||
* Wrapper for rename() that uses #Path names.
|
||||
*/
|
||||
static inline bool RenameFile(const Path &oldpath, const Path &newpath)
|
||||
static inline bool
|
||||
RenameFile(Path oldpath, Path newpath)
|
||||
{
|
||||
return rename(oldpath.c_str(), newpath.c_str()) == 0;
|
||||
}
|
||||
@ -91,8 +95,8 @@ static inline bool RenameFile(const Path &oldpath, const Path &newpath)
|
||||
/**
|
||||
* Wrapper for stat() that uses #Path names.
|
||||
*/
|
||||
static inline bool StatFile(const Path &file, struct stat &buf,
|
||||
bool follow_symlinks = true)
|
||||
static inline bool
|
||||
StatFile(Path file, struct stat &buf, bool follow_symlinks = true)
|
||||
{
|
||||
#ifdef WIN32
|
||||
(void)follow_symlinks;
|
||||
@ -108,7 +112,8 @@ static inline bool StatFile(const Path &file, struct stat &buf,
|
||||
/**
|
||||
* Wrapper for unlink() that uses #Path names.
|
||||
*/
|
||||
static inline bool RemoveFile(const Path &file)
|
||||
static inline bool
|
||||
RemoveFile(Path file)
|
||||
{
|
||||
return unlink(file.c_str()) == 0;
|
||||
}
|
||||
@ -116,12 +121,13 @@ static inline bool RemoveFile(const Path &file)
|
||||
/**
|
||||
* Wrapper for readlink() that uses #Path names.
|
||||
*/
|
||||
Path ReadLink(const Path &path);
|
||||
AllocatedPath
|
||||
ReadLink(Path path);
|
||||
|
||||
#ifndef WIN32
|
||||
|
||||
static inline bool
|
||||
MakeFifo(const Path &path, mode_t mode)
|
||||
MakeFifo(Path path, mode_t mode)
|
||||
{
|
||||
return mkfifo(path.c_str(), mode) == 0;
|
||||
}
|
||||
@ -131,7 +137,8 @@ MakeFifo(const Path &path, mode_t mode)
|
||||
/**
|
||||
* Wrapper for access() that uses #Path names.
|
||||
*/
|
||||
static inline bool CheckAccess(const Path &path, int mode)
|
||||
static inline bool
|
||||
CheckAccess(Path path, int mode)
|
||||
{
|
||||
#ifdef WIN32
|
||||
(void)path;
|
||||
@ -145,8 +152,8 @@ static inline bool CheckAccess(const Path &path, int mode)
|
||||
/**
|
||||
* Checks if #Path exists and is a regular file.
|
||||
*/
|
||||
static inline bool FileExists(const Path &path,
|
||||
bool follow_symlinks = true)
|
||||
static inline bool
|
||||
FileExists(Path path, bool follow_symlinks = true)
|
||||
{
|
||||
struct stat buf;
|
||||
return StatFile(path, buf, follow_symlinks) && S_ISREG(buf.st_mode);
|
||||
@ -155,8 +162,8 @@ static inline bool FileExists(const Path &path,
|
||||
/**
|
||||
* Checks if #Path exists and is a directory.
|
||||
*/
|
||||
static inline bool DirectoryExists(const Path &path,
|
||||
bool follow_symlinks = true)
|
||||
static inline bool
|
||||
DirectoryExists(Path path, bool follow_symlinks = true)
|
||||
{
|
||||
struct stat buf;
|
||||
return StatFile(path, buf, follow_symlinks) && S_ISDIR(buf.st_mode);
|
||||
@ -165,8 +172,8 @@ static inline bool DirectoryExists(const Path &path,
|
||||
/**
|
||||
* Checks if #Path exists.
|
||||
*/
|
||||
static inline bool PathExists(const Path &path,
|
||||
bool follow_symlinks = true)
|
||||
static inline bool
|
||||
PathExists(Path path, bool follow_symlinks = true)
|
||||
{
|
||||
struct stat buf;
|
||||
return StatFile(path, buf, follow_symlinks);
|
||||
|
@ -19,57 +19,12 @@
|
||||
|
||||
#include "config.h"
|
||||
#include "Path.hxx"
|
||||
#include "Domain.hxx"
|
||||
#include "Charset.hxx"
|
||||
#include "util/Error.hxx"
|
||||
#include "Compiler.h"
|
||||
|
||||
#include <glib.h>
|
||||
|
||||
#include <assert.h>
|
||||
#include <string.h>
|
||||
|
||||
inline Path::Path(Donate, pointer _value)
|
||||
:value(_value) {
|
||||
g_free(_value);
|
||||
}
|
||||
|
||||
/* no inlining, please */
|
||||
Path::~Path() {}
|
||||
|
||||
Path
|
||||
Path::Build(const_pointer a, const_pointer b)
|
||||
{
|
||||
return Path(Donate(), g_build_filename(a, b, nullptr));
|
||||
}
|
||||
|
||||
Path Path::FromUTF8(const char *path_utf8)
|
||||
{
|
||||
return Path(Donate(), ::PathFromUTF8(path_utf8));
|
||||
}
|
||||
|
||||
Path
|
||||
Path::FromUTF8(const char *path_utf8, Error &error)
|
||||
{
|
||||
Path path = FromUTF8(path_utf8);
|
||||
if (path.IsNull())
|
||||
error.Format(path_domain,
|
||||
"Failed to convert to file system charset: %s",
|
||||
path_utf8);
|
||||
|
||||
return path;
|
||||
}
|
||||
|
||||
Path
|
||||
Path::GetDirectoryName() const
|
||||
{
|
||||
return Path(Donate(), g_path_get_dirname(value.c_str()));
|
||||
}
|
||||
|
||||
std::string
|
||||
Path::ToUTF8() const
|
||||
{
|
||||
return ::PathToUTF8(value.c_str());
|
||||
return ::PathToUTF8(c_str());
|
||||
}
|
||||
|
||||
const char *
|
||||
@ -93,20 +48,3 @@ Path::RelativeFS(const char *other_fs) const
|
||||
|
||||
return other_fs;
|
||||
}
|
||||
|
||||
void
|
||||
Path::ChopSeparators()
|
||||
{
|
||||
size_t l = length();
|
||||
const char *p = data();
|
||||
|
||||
while (l >= 2 && PathTraits::IsSeparatorFS(p[l - 1])) {
|
||||
--l;
|
||||
|
||||
#if GCC_CHECK_VERSION(4,7) && !defined(__clang__)
|
||||
value.pop_back();
|
||||
#else
|
||||
value.erase(value.end() - 1, value.end());
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
106
src/fs/Path.hxx
106
src/fs/Path.hxx
@ -24,50 +24,33 @@
|
||||
#include "Compiler.h"
|
||||
#include "Traits.hxx"
|
||||
|
||||
#ifdef WIN32
|
||||
#include <glib.h>
|
||||
#endif
|
||||
|
||||
#include <utility>
|
||||
#include <string>
|
||||
|
||||
#include <assert.h>
|
||||
#include <string.h>
|
||||
|
||||
class Error;
|
||||
|
||||
/**
|
||||
* A path name in the native file system character set.
|
||||
*
|
||||
* This class manages a pointer to an existing path string. While an
|
||||
* instance lives, the string must not be invalidated.
|
||||
*/
|
||||
class Path {
|
||||
typedef std::string string;
|
||||
|
||||
typedef PathTraits::value_type value_type;
|
||||
typedef PathTraits::pointer pointer;
|
||||
typedef PathTraits::const_pointer const_pointer;
|
||||
|
||||
string value;
|
||||
const char *value;
|
||||
|
||||
struct Donate {};
|
||||
|
||||
/**
|
||||
* Donate the allocated pointer to a new #Path object.
|
||||
*/
|
||||
Path(Donate, pointer _value);
|
||||
|
||||
Path(const_pointer _value):value(_value) {}
|
||||
constexpr Path(const_pointer _value):value(_value) {}
|
||||
|
||||
public:
|
||||
/**
|
||||
* Copy a #Path object.
|
||||
*/
|
||||
Path(const Path &) = default;
|
||||
|
||||
/**
|
||||
* Move a #Path object.
|
||||
*/
|
||||
Path(Path &&other):value(std::move(other.value)) {}
|
||||
|
||||
~Path();
|
||||
constexpr Path(const Path &) = default;
|
||||
|
||||
/**
|
||||
* Return a "nulled" instance. Its IsNull() method will
|
||||
@ -75,70 +58,29 @@ public:
|
||||
*
|
||||
* @see IsNull()
|
||||
*/
|
||||
gcc_const
|
||||
static Path Null() {
|
||||
return Path("");
|
||||
static constexpr Path Null() {
|
||||
return Path(nullptr);
|
||||
}
|
||||
|
||||
/**
|
||||
* Join two path components with the path separator.
|
||||
* Create a new instance pointing to the specified path
|
||||
* string.
|
||||
*/
|
||||
gcc_pure gcc_nonnull_all
|
||||
static Path Build(const_pointer a, const_pointer b);
|
||||
|
||||
gcc_pure gcc_nonnull_all
|
||||
static Path Build(const_pointer a, const Path &b) {
|
||||
return Build(a, b.c_str());
|
||||
}
|
||||
|
||||
gcc_pure gcc_nonnull_all
|
||||
static Path Build(const Path &a, const_pointer b) {
|
||||
return Build(a.c_str(), b);
|
||||
}
|
||||
|
||||
gcc_pure
|
||||
static Path Build(const Path &a, const Path &b) {
|
||||
return Build(a.c_str(), b.c_str());
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert a C string that is already in the filesystem
|
||||
* character set to a #Path instance.
|
||||
*/
|
||||
gcc_pure
|
||||
static Path FromFS(const_pointer fs) {
|
||||
static constexpr Path FromFS(const_pointer fs) {
|
||||
return Path(fs);
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert a UTF-8 C string to a #Path instance.
|
||||
* Returns return a "nulled" instance on error.
|
||||
*/
|
||||
gcc_pure gcc_nonnull_all
|
||||
static Path FromUTF8(const char *path_utf8);
|
||||
|
||||
gcc_pure gcc_nonnull_all
|
||||
static Path FromUTF8(const char *path_utf8, Error &error);
|
||||
|
||||
/**
|
||||
* Copy a #Path object.
|
||||
*/
|
||||
Path &operator=(const Path &) = default;
|
||||
|
||||
/**
|
||||
* Move a #Path object.
|
||||
*/
|
||||
Path &operator=(Path &&other) {
|
||||
value = std::move(other.value);
|
||||
return *this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if this is a "nulled" instance. A "nulled" instance
|
||||
* must not be used.
|
||||
*/
|
||||
bool IsNull() const {
|
||||
return value.empty();
|
||||
return value == nullptr;
|
||||
}
|
||||
|
||||
/**
|
||||
@ -147,7 +89,7 @@ public:
|
||||
* @see IsNull()
|
||||
*/
|
||||
void SetNull() {
|
||||
value.clear();
|
||||
value = nullptr;
|
||||
}
|
||||
|
||||
/**
|
||||
@ -156,7 +98,9 @@ public:
|
||||
*/
|
||||
gcc_pure
|
||||
size_t length() const {
|
||||
return value.length();
|
||||
assert(value != nullptr);
|
||||
|
||||
return strlen(value);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -166,7 +110,7 @@ public:
|
||||
*/
|
||||
gcc_pure
|
||||
const_pointer c_str() const {
|
||||
return value.c_str();
|
||||
return value;
|
||||
}
|
||||
|
||||
/**
|
||||
@ -175,7 +119,7 @@ public:
|
||||
*/
|
||||
gcc_pure
|
||||
const_pointer data() const {
|
||||
return value.data();
|
||||
return value;
|
||||
}
|
||||
|
||||
/**
|
||||
@ -186,13 +130,6 @@ public:
|
||||
gcc_pure
|
||||
std::string ToUTF8() const;
|
||||
|
||||
/**
|
||||
* Gets directory name of this path.
|
||||
* Returns a "nulled" instance on error.
|
||||
*/
|
||||
gcc_pure
|
||||
Path GetDirectoryName() const;
|
||||
|
||||
/**
|
||||
* Determine the relative part of the given path to this
|
||||
* object, not including the directory separator. Returns an
|
||||
@ -202,11 +139,6 @@ public:
|
||||
gcc_pure
|
||||
const char *RelativeFS(const char *other_fs) const;
|
||||
|
||||
/**
|
||||
* Chop trailing directory separators.
|
||||
*/
|
||||
void ChopSeparators();
|
||||
|
||||
gcc_pure
|
||||
bool IsAbsolute() {
|
||||
return PathTraits::IsAbsoluteFS(c_str());
|
||||
|
@ -23,7 +23,7 @@
|
||||
#include "OutputAPI.hxx"
|
||||
#include "Timer.hxx"
|
||||
#include "system/fd_util.h"
|
||||
#include "fs/Path.hxx"
|
||||
#include "fs/AllocatedPath.hxx"
|
||||
#include "fs/FileSystem.hxx"
|
||||
#include "util/Error.hxx"
|
||||
#include "util/Domain.hxx"
|
||||
@ -41,7 +41,7 @@
|
||||
struct FifoOutput {
|
||||
struct audio_output base;
|
||||
|
||||
Path path;
|
||||
AllocatedPath path;
|
||||
std::string path_utf8;
|
||||
|
||||
int input;
|
||||
@ -50,7 +50,8 @@ struct FifoOutput {
|
||||
Timer *timer;
|
||||
|
||||
FifoOutput()
|
||||
:path(Path::Null()), input(-1), output(-1), created(false) {}
|
||||
:path(AllocatedPath::Null()), input(-1), output(-1),
|
||||
created(false) {}
|
||||
|
||||
bool Initialize(const config_param ¶m, Error &error) {
|
||||
return ao_base_init(&base, &fifo_output_plugin, param,
|
||||
|
Loading…
Reference in New Issue
Block a user