oysteikt/mpd
0
0
Fork 0
Code Issues Pull Requests Releases Activity

fs/Path: rename to AllocatedPath

Browse Source 
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:
Max Kellermann 2013-10-17 21:59:35 +02:00
parent b3611524f4
commit abfbd55305
51 changed files with 621 additions and 394 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Makefile.am
View File

@ -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

3
src/ClientFile.cxx
View File

@ -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;

3
src/ClientFile.hxx
View File

@ -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

24
src/CommandLine.cxx
View File

@ -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()),
USER_CONFIG_FILE_LOCATION_XDG);
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

10
src/ConfigData.cxx
View File

@ -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);

8
src/ConfigData.hxx
View File

@ -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,
Error &error) const;
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;

2
src/ConfigFile.cxx
View File

@ -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();

2
src/ConfigFile.hxx
View File

@ -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

11
src/ConfigGlobal.cxx
View File

@ -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);

13
src/ConfigGlobal.hxx
View File

@ -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

32
src/ConfigPath.cxx
View File

@ -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

4
src/ConfigPath.hxx
View File

@ -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

8
src/Daemon.cxx
View File

@ -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);

6
src/Daemon.hxx
View File

@ -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

2
src/DecoderThread.cxx
View File

@ -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"

4
src/ExcludeList.cxx
View File

@ -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());

4
src/ExcludeList.hxx
View File

@ -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;
};

27
src/InotifyUpdate.cxx
View File

@ -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;

4
src/Listen.cxx
View File

@ -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,

6
src/LogInit.cxx
View File

@ -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();
}

23
src/Main.cxx
View File

@ -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,17 +128,17 @@ 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),
error);
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())
FatalError(error);
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();

69
src/Mapper.cxx
View File

@ -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);
}

17
src/Mapper.hxx
View File

@ -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

4
src/OtherCommands.cxx
View File

@ -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,

37
src/PlaylistFile.cxx
View File

@ -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;

11
src/PlaylistMapper.cxx
View File

@ -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;

12
src/PlaylistSave.cxx
View File

@ -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;

4
src/PlaylistSong.cxx
View File

@ -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;

6
src/QueueCommands.cxx
View File

@ -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,

4
src/SongUpdate.cxx
View File

@ -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;

2
src/StateFile.cxx
View File

@ -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()),

6
src/StateFile.hxx
View File

@ -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();

8
src/StickerDatabase.cxx
View File

@ -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 */

2
src/StickerDatabase.hxx
View File

@ -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.

2
src/TextFile.cxx
View File

@ -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)) {}

2
src/TextFile.hxx
View File

@ -36,7 +36,7 @@ class TextFile {
GString *const buffer;
public:
TextFile(const Path &path_fs);
TextFile(Path path_fs);
TextFile(const TextFile &other) = delete;

4
src/UpdateArchive.cxx
View File

@ -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;

6
src/UpdateContainer.cxx
View File

@ -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(),

12
src/UpdateIO.cxx
View File

@ -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 */

20
src/UpdateWalk.cxx
View File

@ -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;

2
src/db/SimpleDatabasePlugin.cxx
View File

@ -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;

6
src/db/SimpleDatabasePlugin.hxx
View File

@ -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

9
src/decoder/WildmidiDecoderPlugin.cxx
View File

@ -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,9 +40,10 @@ static bool
wildmidi_init(const config_param &param)
{
Error error;
const Path path = param.GetBlockPath("config_file",
"/etc/timidity/timidity.cfg",
error);
const AllocatedPath path =
param.GetBlockPath("config_file",
"/etc/timidity/timidity.cfg",
error);
if (path.IsNull())
FatalError(error);

113
src/fs/AllocatedPath.cxx Normal file
View 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
View 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

8
src/fs/DirectoryReader.hxx
View File

@ -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);
}
};

12
src/fs/FileSystem.cxx
View File

@ -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
}

37
src/fs/FileSystem.hxx
View File

@ -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);

64
src/fs/Path.cxx
View File

@ -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
View File

@ -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());

7
src/output/FifoOutputPlugin.cxx
View File

@ -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 &param, Error &error) {
return ao_base_init(&base, &fifo_output_plugin, param,