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

PlaylistFile: use std::list instead of GPtrArray

Browse Source
This commit is contained in:
Max Kellermann 2012-09-27 23:48:29 +02:00
parent 7298b6c846
commit 609f6ce66d
6 changed files with 114 additions and 159 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
src/OtherCommands.cxx
View File

@ -57,17 +57,13 @@ extern "C" {
#include <string.h>
static void
print_spl_list(struct client *client, GPtrArray *list)
print_spl_list(struct client *client, const PlaylistFileList &list)
{
for (unsigned i = 0; i < list->len; ++i) {
struct stored_playlist_info *playlist =
(struct stored_playlist_info *)
g_ptr_array_index(list, i);
for (const auto &i : list) {
client_printf(client, "playlist: %s\n", i.name.c_str());
client_printf(client, "playlist: %s\n", playlist->name);
if (playlist->mtime > 0)
time_print(client, "Last-Modified", playlist->mtime);
if (i.mtime > 0)
time_print(client, "Last-Modified", i.mtime);
}
}
@ -147,11 +143,8 @@ handle_lsinfo(struct client *client, int argc, char *argv[])
return result;
if (isRootDirectory(uri)) {
GPtrArray *list = spl_list(NULL);
if (list != NULL) {
print_spl_list(client, list);
spl_list_free(list);
}
const auto &list = ListPlaylistFiles(NULL);
print_spl_list(client, list);
}
return COMMAND_RETURN_OK;

19
src/PlaylistCommands.cxx
View File

@ -40,17 +40,13 @@ extern "C" {
#include <stdlib.h>
static void
print_spl_list(struct client *client, GPtrArray *list)
print_spl_list(struct client *client, const PlaylistFileList &list)
{
for (unsigned i = 0; i < list->len; ++i) {
struct stored_playlist_info *playlist =
(struct stored_playlist_info *)
g_ptr_array_index(list, i);
for (const auto &i : list) {
client_printf(client, "playlist: %s\n", i.name.c_str());
client_printf(client, "playlist: %s\n", playlist->name);
if (playlist->mtime > 0)
time_print(client, "Last-Modified", playlist->mtime);
if (i.mtime > 0)
time_print(client, "Last-Modified", i.mtime);
}
}
@ -218,11 +214,10 @@ handle_listplaylists(struct client *client,
G_GNUC_UNUSED int argc, G_GNUC_UNUSED char *argv[])
{
GError *error = NULL;
GPtrArray *list = spl_list(&error);
if (list == NULL)
const auto list = ListPlaylistFiles(&error);
if (list.empty() && error != NULL)
return print_error(client, error);
print_spl_list(client, list);
spl_list_free(list);
return COMMAND_RETURN_OK;
}

153
src/PlaylistFile.cxx
View File

@ -138,83 +138,68 @@ playlist_errno(GError **error_r)
}
}
static struct stored_playlist_info *
load_playlist_info(const char *parent_path_fs, const char *name_fs)
static bool
LoadPlaylistFileInfo(PlaylistFileInfo &info,
const char *parent_path_fs, const char *name_fs)
{
size_t name_length = strlen(name_fs);
if (name_length < sizeof(PLAYLIST_FILE_SUFFIX) ||
memchr(name_fs, '\n', name_length) != NULL)
return NULL;
return false;
if (!g_str_has_suffix(name_fs, PLAYLIST_FILE_SUFFIX))
return NULL;
return false;
char *path_fs = g_build_filename(parent_path_fs, name_fs, NULL);
struct stat st;
int ret = stat(path_fs, &st);
g_free(path_fs);
if (ret < 0 || !S_ISREG(st.st_mode))
return NULL;
return false;
char *name = g_strndup(name_fs,
name_length + 1 - sizeof(PLAYLIST_FILE_SUFFIX));
char *name_utf8 = fs_charset_to_utf8(name);
g_free(name);
if (name_utf8 == NULL)
return NULL;
return false;
struct stored_playlist_info *playlist =
g_new(struct stored_playlist_info, 1);
playlist->name = name_utf8;
playlist->mtime = st.st_mtime;
return playlist;
info.name = name_utf8;
info.mtime = st.st_mtime;
return true;
}
GPtrArray *
spl_list(GError **error_r)
PlaylistFileList
ListPlaylistFiles(GError **error_r)
{
PlaylistFileList list;
const char *parent_path_fs = spl_map(error_r);
if (parent_path_fs == NULL)
return NULL;
return list;
DIR *dir = opendir(parent_path_fs);
if (dir == NULL) {
g_set_error_literal(error_r, g_file_error_quark(), errno,
g_strerror(errno));
return NULL;
return list;
}
GPtrArray *list = g_ptr_array_new();
PlaylistFileInfo info;
struct dirent *ent;
while ((ent = readdir(dir)) != NULL) {
struct stored_playlist_info *playlist =
load_playlist_info(parent_path_fs, ent->d_name);
if (playlist != NULL)
g_ptr_array_add(list, playlist);
if (LoadPlaylistFileInfo(info, parent_path_fs, ent->d_name))
list.push_back(std::move(info));
}
closedir(dir);
return list;
}
void
spl_list_free(GPtrArray *list)
{
for (unsigned i = 0; i < list->len; ++i) {
struct stored_playlist_info *playlist =
(struct stored_playlist_info *)
g_ptr_array_index(list, i);
g_free(playlist->name);
g_free(playlist);
}
g_ptr_array_free(list, true);
}
static bool
spl_save(GPtrArray *list, const char *utf8path, GError **error_r)
SavePlaylistFile(const PlaylistFileContents &contents, const char *utf8path,
GError **error_r)
{
assert(utf8path != NULL);
@ -232,34 +217,32 @@ spl_save(GPtrArray *list, const char *utf8path, GError **error_r)
return false;
}
for (unsigned i = 0; i < list->len; ++i) {
const char *uri = (const char *)g_ptr_array_index(list, i);
playlist_print_uri(file, uri);
}
for (const auto &uri_utf8 : contents)
playlist_print_uri(file, uri_utf8.c_str());
fclose(file);
return true;
}
GPtrArray *
spl_load(const char *utf8path, GError **error_r)
PlaylistFileContents
LoadPlaylistFile(const char *utf8path, GError **error_r)
{
PlaylistFileContents contents;
if (spl_map(error_r) == NULL)
return NULL;
return contents;
char *path_fs = spl_map_to_fs(utf8path, error_r);
if (path_fs == NULL)
return NULL;
return contents;
FILE *file = fopen(path_fs, "r");
g_free(path_fs);
if (file == NULL) {
playlist_errno(error_r);
return NULL;
return contents;
}
GPtrArray *list = g_ptr_array_new();
GString *buffer = g_string_sized_new(1024);
char *s;
while ((s = read_text_line(file, buffer)) != NULL) {
@ -277,47 +260,13 @@ spl_load(const char *utf8path, GError **error_r)
} else
s = g_strdup(s);
g_ptr_array_add(list, s);
if (list->len >= playlist_max_length)
contents.emplace_back(s);
if (contents.size() >= playlist_max_length)
break;
}
fclose(file);
return list;
}
void
spl_free(GPtrArray *list)
{
for (unsigned i = 0; i < list->len; ++i) {
char *uri = (char *)g_ptr_array_index(list, i);
g_free(uri);
}
g_ptr_array_free(list, true);
}
static char *
spl_remove_index_internal(GPtrArray *list, unsigned idx)
{
assert(idx < list->len);
char *uri = (char *)g_ptr_array_remove_index(list, idx);
assert(uri != NULL);
return uri;
}
static void
spl_insert_index_internal(GPtrArray *list, unsigned idx, char *uri)
{
assert(idx <= list->len);
g_ptr_array_add(list, uri);
memmove(list->pdata + idx + 1, list->pdata + idx,
(list->len - idx - 1) * sizeof(list->pdata[0]));
g_ptr_array_index(list, idx) = uri;
return contents;
}
bool
@ -329,24 +278,28 @@ spl_move_index(const char *utf8path, unsigned src, unsigned dest,
what the hell.. */
return true;
GPtrArray *list = spl_load(utf8path, error_r);
if (list == NULL)
GError *error = nullptr;
auto contents = LoadPlaylistFile(utf8path, &error);
if (contents.empty() && error != nullptr) {
g_propagate_error(error_r, error);
return false;
}
if (src >= list->len || dest >= list->len) {
spl_free(list);
if (src >= contents.size() || dest >= contents.size()) {
g_set_error_literal(error_r, playlist_quark(),
PLAYLIST_RESULT_BAD_RANGE,
"Bad range");
return false;
}
char *uri = spl_remove_index_internal(list, src);
spl_insert_index_internal(list, dest, uri);
const auto src_i = std::next(contents.begin(), src);
auto value = std::move(*src_i);
contents.erase(src_i);
bool result = spl_save(list, utf8path, error_r);
const auto dest_i = std::next(contents.begin(), dest);
contents.insert(dest_i, std::move(value));
spl_free(list);
bool result = SavePlaylistFile(contents, utf8path, error_r);
idle_add(IDLE_STORED_PLAYLIST);
return result;
@ -398,23 +351,23 @@ spl_delete(const char *name_utf8, GError **error_r)
bool
spl_remove_index(const char *utf8path, unsigned pos, GError **error_r)
{
GPtrArray *list = spl_load(utf8path, error_r);
if (list == NULL)
GError *error = nullptr;
auto contents = LoadPlaylistFile(utf8path, &error);
if (contents.empty() && error != nullptr) {
g_propagate_error(error_r, error);
return false;
}
if (pos >= list->len) {
spl_free(list);
if (pos >= contents.size()) {
g_set_error_literal(error_r, playlist_quark(),
PLAYLIST_RESULT_BAD_RANGE,
"Bad range");
return false;
}
char *uri = spl_remove_index_internal(list, pos);
g_free(uri);
bool result = spl_save(list, utf8path, error_r);
contents.erase(std::next(contents.begin(), pos));
spl_free(list);
bool result = SavePlaylistFile(contents, utf8path, error_r);
idle_add(IDLE_STORED_PLAYLIST);
return result;

38
src/PlaylistFile.h
View File

@ -20,18 +20,32 @@
#ifndef MPD_STORED_PLAYLIST_H
#define MPD_STORED_PLAYLIST_H
#ifdef __cplusplus
#include <list>
#include <vector>
#include <string>
#endif
#include <glib.h>
#include <stdbool.h>
#include <time.h>
struct song;
struct stored_playlist_info {
char *name;
#ifdef __cplusplus
struct PlaylistFileInfo {
std::string name;
time_t mtime;
};
typedef std::list<PlaylistFileInfo> PlaylistFileList;
typedef std::vector<std::string> PlaylistFileContents;
#endif
extern bool playlist_saveAbsolutePaths;
G_BEGIN_DECLS
@ -42,6 +56,10 @@ G_BEGIN_DECLS
void
spl_global_init(void);
G_END_DECLS
#ifdef __cplusplus
/**
* Determines whether the specified string is a valid name for a
* stored playlist.
@ -53,17 +71,11 @@ spl_valid_name(const char *name_utf8);
* Returns a list of stored_playlist_info struct pointers. Returns
* NULL if an error occurred.
*/
GPtrArray *
spl_list(GError **error_r);
PlaylistFileList
ListPlaylistFiles(GError **error_r);
void
spl_list_free(GPtrArray *list);
GPtrArray *
spl_load(const char *utf8path, GError **error_r);
void
spl_free(GPtrArray *list);
PlaylistFileContents
LoadPlaylistFile(const char *utf8path, GError **error_r);
bool
spl_move_index(const char *utf8path, unsigned src, unsigned dest,
@ -87,6 +99,6 @@ spl_append_uri(const char *file, const char *utf8file, GError **error_r);
bool
spl_rename(const char *utf8from, const char *utf8to, GError **error_r);
G_END_DECLS
#endif
#endif

18
src/PlaylistPrint.cxx
View File

@ -116,18 +116,18 @@ bool
spl_print(struct client *client, const char *name_utf8, bool detail,
GError **error_r)
{
GPtrArray *list;
list = spl_load(name_utf8, error_r);
if (list == NULL)
GError *error = NULL;
PlaylistFileContents contents = LoadPlaylistFile(name_utf8, &error);
if (contents.empty() && error != nullptr) {
g_propagate_error(error_r, error);
return false;
}
for (unsigned i = 0; i < list->len; ++i) {
const char *temp = (const char *)g_ptr_array_index(list, i);
for (const auto &uri_utf8 : contents) {
bool wrote = false;
if (detail) {
struct song *song = db_get_song(temp);
struct song *song = db_get_song(uri_utf8.c_str());
if (song) {
song_print_info(client, song);
db_return_song(song);
@ -136,11 +136,11 @@ spl_print(struct client *client, const char *name_utf8, bool detail,
}
if (!wrote) {
client_printf(client, SONG_FILE "%s\n", temp);
client_printf(client, SONG_FILE "%s\n",
uri_utf8.c_str());
}
}
spl_free(list);
return true;
}

24
src/PlaylistSave.cxx
View File

@ -119,33 +119,35 @@ playlist_load_spl(struct playlist *playlist, struct player_control *pc,
unsigned start_index, unsigned end_index,
GError **error_r)
{
GPtrArray *list;
list = spl_load(name_utf8, error_r);
if (list == NULL)
GError *error = NULL;
PlaylistFileContents contents = LoadPlaylistFile(name_utf8, &error);
if (contents.empty() && error != nullptr) {
g_propagate_error(error_r, error);
return false;
}
if (list->len < end_index)
end_index = list->len;
if (end_index > contents.size())
end_index = contents.size();
for (unsigned i = start_index; i < end_index; ++i) {
const char *temp = (const char *)g_ptr_array_index(list, i);
if ((playlist_append_uri(playlist, pc, temp, NULL)) != PLAYLIST_RESULT_SUCCESS) {
const auto &uri_utf8 = contents[i];
if ((playlist_append_uri(playlist, pc, uri_utf8.c_str(),
nullptr)) != PLAYLIST_RESULT_SUCCESS) {
/* for windows compatibility, convert slashes */
char *temp2 = g_strdup(temp);
char *temp2 = g_strdup(uri_utf8.c_str());
char *p = temp2;
while (*p) {
if (*p == '\\')
*p = '/';
p++;
}
if ((playlist_append_uri(playlist, pc, temp, NULL)) != PLAYLIST_RESULT_SUCCESS) {
if ((playlist_append_uri(playlist, pc, temp2, NULL)) != PLAYLIST_RESULT_SUCCESS) {
g_warning("can't add file \"%s\"", temp2);
}
g_free(temp2);
}
}
spl_free(list);
return true;
}