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

Path: move to fs subdirectory

Browse Source
This commit is contained in:
Denis Krjuchkov
2013-01-22 00:14:37 +06:00
parent 4ad90e2d52
commit ef93cdf4a8
22 changed files with 24 additions and 24 deletions
Download Patch File Download Diff File Expand all files Collapse all files

131
src/fs/Path.cxx Normal file
View File

@@ -0,0 +1,131 @@
/*
* 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 "fs/Path.hxx"
#include "conf.h"
#include "mpd_error.h"
#include "gcc.h"
#include <glib.h>
#include <assert.h>
#include <string.h>
#ifdef G_OS_WIN32
#include <windows.h> // for GetACP()
#include <stdio.h> // for sprintf()
#endif
#undef G_LOG_DOMAIN
#define G_LOG_DOMAIN "path"
static char *fs_charset;
char *
fs_charset_to_utf8(const char *path_fs)
{
return g_convert(path_fs, -1,
"utf-8", fs_charset,
NULL, NULL, NULL);
}
char *
utf8_to_fs_charset(const char *path_utf8)
{
gchar *p;
p = g_convert(path_utf8, -1,
fs_charset, "utf-8",
NULL, NULL, NULL);
if (p == NULL)
/* fall back to UTF-8 */
p = g_strdup(path_utf8);
return p;
}
gcc_pure
static bool
IsSupportedCharset(const char *charset)
{
/* convert a space to check if the charset is valid */
char *test = g_convert(" ", 1, charset, "UTF-8", NULL, NULL, NULL);
if (test == NULL)
return false;
g_free(test);
return true;
}
static void
path_set_fs_charset(const char *charset)
{
assert(charset != NULL);
if (!IsSupportedCharset(charset))
MPD_ERROR("invalid filesystem charset: %s", charset);
g_free(fs_charset);
fs_charset = g_strdup(charset);
g_debug("path_set_fs_charset: fs charset is: %s", fs_charset);
}
const char *path_get_fs_charset(void)
{
return fs_charset;
}
void path_global_init(void)
{
const char *charset = NULL;
charset = config_get_string(CONF_FS_CHARSET, NULL);
if (charset == NULL) {
#ifndef G_OS_WIN32
const gchar **encodings;
g_get_filename_charsets(&encodings);
if (encodings[0] != NULL && *encodings[0] != '\0')
charset = encodings[0];
#else /* G_OS_WIN32 */
/* Glib claims that file system encoding is always utf-8
* on native Win32 (i.e. not Cygwin).
* However this is true only if <gstdio.h> helpers are used.
* MPD uses regular <stdio.h> functions.
* Those functions use encoding determined by GetACP(). */
static char win_charset[13];
sprintf(win_charset, "cp%u", GetACP());
charset = win_charset;
#endif
}
if (charset) {
path_set_fs_charset(charset);
} else {
g_message("setting filesystem charset to ISO-8859-1");
path_set_fs_charset("ISO-8859-1");
}
}
void path_global_finish(void)
{
g_free(fs_charset);
}

264
src/fs/Path.hxx Normal file
View File

@@ -0,0 +1,264 @@
/*
* 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_PATH_HXX
#define MPD_FS_PATH_HXX
#include "check.h"
#include "gcc.h"
#include <glib.h>
#include <algorithm>
#include <assert.h>
#include <string.h>
#include <limits.h>
#if !defined(MPD_PATH_MAX)
# if defined(MAXPATHLEN)
# define MPD_PATH_MAX MAXPATHLEN
# elif defined(PATH_MAX)
# define MPD_PATH_MAX PATH_MAX
# else
# define MPD_PATH_MAX 256
# endif
#endif
void path_global_init();
void path_global_finish();
/**
* Converts a file name in the filesystem charset to UTF-8. Returns
* NULL on failure.
*/
char *
fs_charset_to_utf8(const char *path_fs);
/**
* Converts a file name in UTF-8 to the filesystem charset. Returns a
* duplicate of the UTF-8 string on failure.
*/
char *
utf8_to_fs_charset(const char *path_utf8);
const char *path_get_fs_charset();
/**
* A path name in the native file system character set.
*/
class Path {
public:
typedef char value_type;
typedef value_type *pointer;
typedef const value_type *const_pointer;
private:
pointer value;
struct Donate {};
/**
* Donate the allocated pointer to a new #Path object.
*/
constexpr Path(Donate, pointer _value):value(_value) {}
/**
* Release memory allocated by the value, but do not clear the
* value pointer.
*/
void Free() {
/* free() can be optimized by gcc, while g_free() can
not: when the compiler knows that the value is
nullptr, it will not emit a free() call in the
inlined destructor; however on Windows, we need to
call g_free(), because the value has been allocated
by GLib, and on Windows, this matters */
#ifdef WIN32
g_free(value);
#else
free(value);
#endif
}
public:
/**
* Copy a #Path object.
*/
Path(const Path &other)
:value(g_strdup(other.value)) {}
/**
* Move a #Path object.
*/
Path(Path &&other):value(other.value) {
other.value = nullptr;
}
~Path() {
Free();
}
/**
* Return a "nulled" instance. Its IsNull() method will
* return true. Such an object must not be used.
*
* @see IsNull()
*/
gcc_const
static Path Null() {
return Path(Donate(), nullptr);
}
/**
* Join two path components with the path separator.
*/
gcc_pure gcc_nonnull_all
static Path Build(const_pointer a, const_pointer b) {
return Path(Donate(), g_build_filename(a, b, nullptr));
}
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) {
return Path(Donate(), g_strdup(fs));
}
/**
* Convert a UTF-8 C string to a #Path instance.
*
* TODO: return a "nulled" instance on error and add checks to
* all callers
*/
gcc_pure
static Path FromUTF8(const char *utf8) {
return Path(Donate(), utf8_to_fs_charset(utf8));
}
/**
* Copy a #Path object.
*/
Path &operator=(const Path &other) {
if (this != &other) {
Free();
value = g_strdup(other.value);
}
return *this;
}
/**
* Move a #Path object.
*/
Path &operator=(Path &&other) {
std::swap(value, other.value);
return *this;
}
/**
* Steal the allocated value. This object has an undefined
* value, and the caller is response for freeing this method's
* return value.
*/
pointer Steal() {
pointer result = value;
value = nullptr;
return result;
}
/**
* Check if this is a "nulled" instance. A "nulled" instance
* must not be used.
*/
bool IsNull() const {
return value == nullptr;
}
/**
* Clear this object's value, make it "nulled".
*
* @see IsNull()
*/
void SetNull() {
Free();
value = nullptr;
}
gcc_pure
bool empty() const {
assert(value != nullptr);
return *value == 0;
}
/**
* @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 {
assert(value != nullptr);
return strlen(value);
}
/**
* 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 {
assert(value != nullptr);
return value;
}
/**
* Convert the path to UTF-8. The caller is responsible for
* freeing the return value with g_free(). Returns nullptr on
* error.
*/
char *ToUTF8() const {
return value != nullptr
? fs_charset_to_utf8(value)
: nullptr;
}
};
#endif