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

db_plugin: convert to C++

Browse Source
This commit is contained in:
Max Kellermann 2012-07-30 07:26:08 +02:00
parent 37b92967c5
commit 9dc9459f3a
10 changed files with 368 additions and 394 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
Makefile.am
View File

@ -246,18 +246,18 @@ src_mpd_SOURCES = \
src/decoder_api.c \
src/decoder_internal.c \
src/decoder_print.c \
src/directory.c \
src/Directory.cxx \
src/directory_save.c \
src/database.c \
src/db_internal.h \
src/DatabaseGlue.cxx \
src/db_error.h \
src/db_lock.c src/db_lock.h \
src/db_save.c src/db_save.h \
src/db_print.c src/db_print.h \
src/db_plugin.h \
src/db_visitor.h \
src/DatabasePlugin.hxx \
src/DatabaseVisitor.hxx \
src/db_selection.h \
src/db/simple_db_plugin.c src/db/simple_db_plugin.h \
src/db/SimpleDatabasePlugin.cxx src/db/SimpleDatabasePlugin.hxx \
src/exclude.c \
src/fd_util.c \
src/fifo_buffer.c src/fifo_buffer.h \

55
src/database.c → src/DatabaseGlue.cxx
View File

@ -18,17 +18,22 @@
*/
#include "config.h"
extern "C" {
#include "database.h"
#include "db_error.h"
#include "db_save.h"
#include "db_selection.h"
#include "db_visitor.h"
#include "db_plugin.h"
#include "db/simple_db_plugin.h"
#include "directory.h"
#include "stats.h"
#include "conf.h"
#include "glib_compat.h"
}
#include "directory.h"
#include "DatabasePlugin.hxx"
#include "db/SimpleDatabasePlugin.hxx"
#include <glib.h>
@ -42,7 +47,7 @@
#undef G_LOG_DOMAIN
#define G_LOG_DOMAIN "database"
static struct db *db;
static Database *db;
static bool db_is_open;
bool
@ -57,7 +62,7 @@ db_init(const struct config_param *path, GError **error_r)
struct config_param *param = config_new_param("database", path->line);
config_add_block_param(param, "path", path->value, path->line);
db = db_plugin_new(&simple_db_plugin, param, error_r);
db = simple_db_plugin.create(param, error_r);
config_param_free(param);
@ -68,10 +73,10 @@ void
db_finish(void)
{
if (db_is_open)
db_plugin_close(db);
db->Close();
if (db != NULL)
db_plugin_free(db);
delete db;
}
struct directory *
@ -79,7 +84,7 @@ db_get_root(void)
{
assert(db != NULL);
return simple_db_get_root(db);
return ((SimpleDatabase *)db)->GetRoot();
}
struct directory *
@ -107,7 +112,7 @@ db_get_song(const char *file)
if (db == NULL)
return NULL;
return db_plugin_get_song(db, file, NULL);
return db->GetSong(file, NULL);
}
bool
@ -121,7 +126,31 @@ db_visit(const struct db_selection *selection,
return false;
}
return db_plugin_visit(db, selection, visitor, ctx, error_r);
VisitDirectory visit_directory;
if (visitor->directory != NULL)
visit_directory = [&](const struct directory *directory,
GError **error_r2) {
return visitor->directory(directory, ctx, error_r2);
};
VisitSong visit_song;
if (visitor->song != NULL)
visit_song = [&](struct song *song, GError **error_r2) {
return visitor->song(song, ctx, error_r2);
};
VisitPlaylist visit_playlist;
if (visitor->playlist != NULL)
visit_playlist = [&](const struct playlist_metadata *playlist,
const struct directory *directory,
GError **error_r2) {
return visitor->playlist(playlist, directory, ctx,
error_r2);
};
return db->Visit(selection,
visit_directory, visit_song, visit_playlist,
error_r);
}
bool
@ -141,7 +170,7 @@ db_save(GError **error_r)
assert(db != NULL);
assert(db_is_open);
return simple_db_save(db, error_r);
return ((SimpleDatabase *)db)->Save(error_r);
}
bool
@ -150,7 +179,7 @@ db_load(GError **error)
assert(db != NULL);
assert(!db_is_open);
if (!db_plugin_open(db, error))
if (!db->Open(error))
return false;
db_is_open = true;
@ -166,5 +195,5 @@ db_get_mtime(void)
assert(db != NULL);
assert(db_is_open);
return simple_db_get_mtime(db);
return ((SimpleDatabase *)db)->GetLastModified();
}

87
src/DatabasePlugin.hxx Normal file
View File

@ -0,0 +1,87 @@
/*
* Copyright (C) 2003-2011 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.
*/
/** \file
*
* This header declares the db_plugin class. It describes a
* plugin API for databases of song metadata.
*/
#ifndef MPD_DATABASE_PLUGIN_HXX
#define MPD_DATABASE_PLUGIN_HXX
#include "DatabaseVisitor.hxx"
#include <glib.h>
#include <assert.h>
#include <stdbool.h>
struct config_param;
struct db_selection;
struct db_visitor;
class Database {
public:
/**
* Free instance data.
*/
virtual ~Database() {}
/**
* Open the database. Read it into memory if applicable.
*/
virtual bool Open(G_GNUC_UNUSED GError **error_r) {
return true;
}
/**
* Close the database, free allocated memory.
*/
virtual void Close() {}
/**
* Look up a song (including tag data) in the database.
*
* @param uri_utf8 the URI of the song within the music
* directory (UTF-8)
*/
virtual struct song *GetSong(const char *uri_utf8,
GError **error_r) = 0;
/**
* Visit the selected entities.
*/
virtual bool Visit(const struct db_selection *selection,
VisitDirectory visit_directory,
VisitSong visit_song,
VisitPlaylist visit_playlist,
GError **error_r) = 0;
};
struct DatabasePlugin {
const char *name;
/**
* Allocates and configures a database.
*/
Database *(*create)(const struct config_param *param,
GError **error_r);
};
#endif

27
src/db/simple_db_plugin.h → src/DatabaseVisitor.hxx
View File

@ -17,26 +17,19 @@
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#ifndef MPD_SIMPLE_DB_PLUGIN_H
#define MPD_SIMPLE_DB_PLUGIN_H
#ifndef MPD_DATABASE_VISITOR_HXX
#define MPD_DATABASE_VISITOR_HXX
#include <functional>
#include <glib.h>
#include <stdbool.h>
#include <time.h>
extern const struct db_plugin simple_db_plugin;
struct directory;
struct song;
struct playlist_metadata;
struct db;
G_GNUC_PURE
struct directory *
simple_db_get_root(struct db *db);
bool
simple_db_save(struct db *db, GError **error_r);
G_GNUC_PURE
time_t
simple_db_get_mtime(const struct db *db);
typedef std::function<bool(const struct directory *, GError **)> VisitDirectory;
typedef std::function<bool(struct song *, GError **)> VisitSong;
typedef std::function<bool(const struct playlist_metadata *, const struct directory *, GError **)> VisitPlaylist;
#endif

40
src/directory.c → src/Directory.cxx
View File

@ -19,6 +19,8 @@
#include "config.h"
#include "directory.h"
extern "C" {
#include "song.h"
#include "song_sort.h"
#include "playlist_vector.h"
@ -26,6 +28,7 @@
#include "util/list_sort.h"
#include "db_visitor.h"
#include "db_lock.h"
}
#include <glib.h>
@ -36,14 +39,15 @@
struct directory *
directory_new(const char *path, struct directory *parent)
{
struct directory *directory;
size_t pathlen = strlen(path);
assert(path != NULL);
assert((*path == 0) == (parent == NULL));
directory = g_malloc0(sizeof(*directory) -
sizeof(directory->path) + pathlen + 1);
struct directory *directory =
(struct directory *)g_malloc0(sizeof(*directory)
- sizeof(directory->path)
+ pathlen + 1);
INIT_LIST_HEAD(&directory->children);
INIT_LIST_HEAD(&directory->songs);
INIT_LIST_HEAD(&directory->playlists);
@ -277,36 +281,36 @@ directory_sort(struct directory *directory)
}
bool
directory_walk(const struct directory *directory, bool recursive,
const struct db_visitor *visitor, void *ctx,
GError **error_r)
directory::Walk(bool recursive,
VisitDirectory visit_directory, VisitSong visit_song,
VisitPlaylist visit_playlist,
GError **error_r) const
{
assert(directory != NULL);
assert(visitor != NULL);
assert(error_r == NULL || *error_r == NULL);
if (visitor->song != NULL) {
if (visit_song) {
struct song *song;
directory_for_each_song(song, directory)
if (!visitor->song(song, ctx, error_r))
directory_for_each_song(song, this)
if (!visit_song(song, error_r))
return false;
}
if (visitor->playlist != NULL) {
if (visit_playlist) {
struct playlist_metadata *i;
directory_for_each_playlist(i, directory)
if (!visitor->playlist(i, directory, ctx, error_r))
directory_for_each_playlist(i, this)
if (!visit_playlist(i, this, error_r))
return false;
}
struct directory *child;
directory_for_each_child(child, directory) {
if (visitor->directory != NULL &&
!visitor->directory(child, ctx, error_r))
directory_for_each_child(child, this) {
if (visit_directory &&
!visit_directory(child, error_r))
return false;
if (recursive &&
!directory_walk(child, recursive, visitor, ctx, error_r))
!child->Walk(recursive, visit_directory, visit_song,
visit_playlist, error_r))
return false;
}

244
src/db/simple_db_plugin.c → src/db/SimpleDatabasePlugin.cxx
View File

@ -18,14 +18,17 @@
*/
#include "config.h"
#include "simple_db_plugin.h"
#include "db_internal.h"
#include "SimpleDatabasePlugin.hxx"
extern "C" {
#include "db_error.h"
#include "db_selection.h"
#include "db_visitor.h"
#include "db_save.h"
#include "db_lock.h"
#include "conf.h"
}
#include "directory.h"
#include <sys/types.h>
@ -33,16 +36,6 @@
#include <unistd.h>
#include <errno.h>
struct simple_db {
struct db base;
char *path;
struct directory *root;
time_t mtime;
};
G_GNUC_CONST
static inline GQuark
simple_db_quark(void)
@ -50,63 +43,50 @@ simple_db_quark(void)
return g_quark_from_static_string("simple_db");
}
G_GNUC_PURE
static const struct directory *
simple_db_lookup_directory(const struct simple_db *db, const char *uri)
Database *
SimpleDatabase::Create(const struct config_param *param, GError **error_r)
{
assert(db != NULL);
assert(db->root != NULL);
assert(uri != NULL);
SimpleDatabase *db = new SimpleDatabase();
if (!db->Configure(param, error_r)) {
delete db;
db = NULL;
}
db_lock();
struct directory *directory =
directory_lookup_directory(db->root, uri);
db_unlock();
return directory;
return db;
}
static struct db *
simple_db_init(const struct config_param *param, GError **error_r)
bool
SimpleDatabase::Configure(const struct config_param *param, GError **error_r)
{
struct simple_db *db = g_malloc(sizeof(*db));
db_base_init(&db->base, &simple_db_plugin);
GError *error = NULL;
db->path = config_dup_block_path(param, "path", &error);
if (db->path == NULL) {
g_free(db);
char *_path = config_dup_block_path(param, "path", &error);
if (_path == NULL) {
if (error != NULL)
g_propagate_error(error_r, error);
else
g_set_error(error_r, simple_db_quark(), 0,
"No \"path\" parameter specified");
return NULL;
return false;
}
return &db->base;
path = _path;
free(_path);
return true;
}
static void
simple_db_finish(struct db *_db)
bool
SimpleDatabase::Check(GError **error_r) const
{
struct simple_db *db = (struct simple_db *)_db;
g_free(db->path);
g_free(db);
}
static bool
simple_db_check(struct simple_db *db, GError **error_r)
{
assert(db != NULL);
assert(db->path != NULL);
assert(!path.empty());
/* Check if the file exists */
if (access(db->path, F_OK)) {
if (access(path.c_str(), F_OK)) {
/* 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 */
char *dirPath = g_path_get_dirname(db->path);
char *dirPath = g_path_get_dirname(path.c_str());
/* Check that the parent part of the path is a directory */
struct stat st;
@ -115,7 +95,7 @@ simple_db_check(struct simple_db *db, GError **error_r)
g_set_error(error_r, simple_db_quark(), errno,
"Couldn't stat parent directory of db file "
"\"%s\": %s",
db->path, g_strerror(errno));
path.c_str(), g_strerror(errno));
return false;
}
@ -124,7 +104,7 @@ simple_db_check(struct simple_db *db, GError **error_r)
g_set_error(error_r, simple_db_quark(), 0,
"Couldn't create db file \"%s\" because the "
"parent path is not a directory",
db->path);
path.c_str());
return false;
}
@ -144,47 +124,46 @@ simple_db_check(struct simple_db *db, GError **error_r)
/* Path exists, now check if it's a regular file */
struct stat st;
if (stat(db->path, &st) < 0) {
if (stat(path.c_str(), &st) < 0) {
g_set_error(error_r, simple_db_quark(), errno,
"Couldn't stat db file \"%s\": %s",
db->path, g_strerror(errno));
path.c_str(), g_strerror(errno));
return false;
}
if (!S_ISREG(st.st_mode)) {
g_set_error(error_r, simple_db_quark(), 0,
"db file \"%s\" is not a regular file",
db->path);
path.c_str());
return false;
}
/* And check that we can write to it */
if (access(db->path, R_OK | W_OK)) {
if (access(path.c_str(), R_OK | W_OK)) {
g_set_error(error_r, simple_db_quark(), errno,
"Can't open db file \"%s\" for reading/writing: %s",
db->path, g_strerror(errno));
path.c_str(), g_strerror(errno));
return false;
}
return true;
}
static bool
simple_db_load(struct simple_db *db, GError **error_r)
bool
SimpleDatabase::Load(GError **error_r)
{
assert(db != NULL);
assert(db->path != NULL);
assert(db->root != NULL);
assert(!path.empty());
assert(root != NULL);
FILE *fp = fopen(db->path, "r");
FILE *fp = fopen(path.c_str(), "r");
if (fp == NULL) {
g_set_error(error_r, simple_db_quark(), errno,
"Failed to open database file \"%s\": %s",
db->path, g_strerror(errno));
path.c_str(), g_strerror(errno));
return false;
}
if (!db_load_internal(fp, db->root, error_r)) {
if (!db_load_internal(fp, root, error_r)) {
fclose(fp);
return false;
}
@ -192,55 +171,49 @@ simple_db_load(struct simple_db *db, GError **error_r)
fclose(fp);
struct stat st;
if (stat(db->path, &st) == 0)
db->mtime = st.st_mtime;
if (stat(path.c_str(), &st) == 0)
mtime = st.st_mtime;
return true;
}
static bool
simple_db_open(struct db *_db, G_GNUC_UNUSED GError **error_r)
bool
SimpleDatabase::Open(GError **error_r)
{
struct simple_db *db = (struct simple_db *)_db;
db->root = directory_new_root();
db->mtime = 0;
root = directory_new_root();
mtime = 0;
GError *error = NULL;
if (!simple_db_load(db, &error)) {
directory_free(db->root);
if (!Load(&error)) {
directory_free(root);
g_warning("Failed to load database: %s", error->message);
g_error_free(error);
if (!simple_db_check(db, error_r))
if (!Check(error_r))
return false;
db->root = directory_new_root();
root = directory_new_root();
}
return true;
}
static void
simple_db_close(struct db *_db)
void
SimpleDatabase::Close()
{
struct simple_db *db = (struct simple_db *)_db;
assert(root != NULL);
assert(db->root != NULL);
directory_free(db->root);
directory_free(root);
}
static struct song *
simple_db_get_song(struct db *_db, const char *uri, GError **error_r)
struct song *
SimpleDatabase::GetSong(const char *uri, GError **error_r)
{
struct simple_db *db = (struct simple_db *)_db;
assert(db->root != NULL);
assert(root != NULL);
db_lock();
struct song *song = directory_lookup_song(db->root, uri);
struct song *song = directory_lookup_song(root, uri);
db_unlock();
if (song == NULL)
g_set_error(error_r, db_quark(), DB_NOT_FOUND,
@ -249,84 +222,75 @@ simple_db_get_song(struct db *_db, const char *uri, GError **error_r)
return song;
}
static bool
simple_db_visit(struct db *_db, const struct db_selection *selection,
const struct db_visitor *visitor, void *ctx,
GError **error_r)
G_GNUC_PURE
const struct directory *
SimpleDatabase::LookupDirectory(const char *uri) const
{
const struct simple_db *db = (const struct simple_db *)_db;
const struct directory *directory =
simple_db_lookup_directory(db, selection->uri);
assert(root != NULL);
assert(uri != NULL);
db_lock();
struct directory *directory =
directory_lookup_directory(root, uri);
db_unlock();
return directory;
}
bool
SimpleDatabase::Visit(const struct db_selection *selection,
VisitDirectory visit_directory,
VisitSong visit_song,
VisitPlaylist visit_playlist,
GError **error_r)
{
const struct directory *directory = LookupDirectory(selection->uri);
if (directory == NULL) {
struct song *song;
if (visitor->song != NULL &&
(song = simple_db_get_song(_db, selection->uri, NULL)) != NULL)
return visitor->song(song, ctx, error_r);
if (visit_song &&
(song = GetSong(selection->uri, NULL)) != NULL)
return visit_song(song, error_r);
g_set_error(error_r, db_quark(), DB_NOT_FOUND,
"No such directory");
return false;
}
if (selection->recursive && visitor->directory != NULL &&
!visitor->directory(directory, ctx, error_r))
if (selection->recursive && visit_directory &&
!visit_directory(directory, error_r))
return false;
db_lock();
bool ret = directory_walk(directory, selection->recursive,
visitor, ctx, error_r);
bool ret = directory->Walk(selection->recursive,
visit_directory, visit_song, visit_playlist,
error_r);
db_unlock();
return ret;
}
const struct db_plugin simple_db_plugin = {
.name = "simple",
.init = simple_db_init,
.finish = simple_db_finish,
.open = simple_db_open,
.close = simple_db_close,
.get_song = simple_db_get_song,
.visit = simple_db_visit,
};
struct directory *
simple_db_get_root(struct db *_db)
{
struct simple_db *db = (struct simple_db *)_db;
assert(db != NULL);
assert(db->root != NULL);
return db->root;
}
bool
simple_db_save(struct db *_db, GError **error_r)
SimpleDatabase::Save(GError **error_r)
{
struct simple_db *db = (struct simple_db *)_db;
struct directory *music_root = db->root;
db_lock();
g_debug("removing empty directories from DB");
directory_prune_empty(music_root);
directory_prune_empty(root);
g_debug("sorting DB");
directory_sort(music_root);
directory_sort(root);
db_unlock();
g_debug("writing DB");
FILE *fp = fopen(db->path, "w");
FILE *fp = fopen(path.c_str(), "w");
if (!fp) {
g_set_error(error_r, simple_db_quark(), errno,
"unable to write to db file \"%s\": %s",
db->path, g_strerror(errno));
path.c_str(), g_strerror(errno));
return false;
}
db_save_internal(fp, music_root);
db_save_internal(fp, root);
if (ferror(fp)) {
g_set_error(error_r, simple_db_quark(), errno,
@ -339,19 +303,13 @@ simple_db_save(struct db *_db, GError **error_r)
fclose(fp);
struct stat st;
if (stat(db->path, &st) == 0)
db->mtime = st.st_mtime;
if (stat(path.c_str(), &st) == 0)
mtime = st.st_mtime;
return true;
}
time_t
simple_db_get_mtime(const struct db *_db)
{
const struct simple_db *db = (const struct simple_db *)_db;
assert(db != NULL);
assert(db->root != NULL);
return db->mtime;
}
const DatabasePlugin simple_db_plugin = {
"simple",
SimpleDatabase::Create,
};

84
src/db/SimpleDatabasePlugin.hxx Normal file
View File

@ -0,0 +1,84 @@
/*
* Copyright (C) 2003-2011 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_SIMPLE_DATABASE_PLUGIN_HXX
#define MPD_SIMPLE_DATABASE_PLUGIN_HXX
#include "DatabasePlugin.hxx"
#include "gcc.h"
#include <cassert>
#include <string>
#include <glib.h>
#include <stdbool.h>
#include <time.h>
struct directory;
class SimpleDatabase : public Database {
std::string path;
struct directory *root;
time_t mtime;
public:
G_GNUC_PURE
struct directory *GetRoot() {
assert(root != NULL);
return root;
}
bool Save(GError **error_r);
G_GNUC_PURE
time_t GetLastModified() const {
return mtime;
}
static Database *Create(const struct config_param *param,
GError **error_r);
virtual bool Open(GError **error_r) override;
virtual void Close() override;
virtual struct song *GetSong(const char *uri_utf8,
GError **error_r) override;
virtual bool Visit(const struct db_selection *selection,
VisitDirectory visit_directory,
VisitSong visit_song,
VisitPlaylist visit_playlist,
GError **error_r) override;
protected:
bool Configure(const struct config_param *param, GError **error_r);
G_GNUC_PURE
bool Check(GError **error_r) const;
bool Load(GError **error_r);
G_GNUC_PURE
const struct directory *LookupDirectory(const char *uri) const;
};
extern const DatabasePlugin simple_db_plugin;
#endif

35
src/db_internal.h
View File

@ -1,35 +0,0 @@
/*
* Copyright (C) 2003-2011 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_DB_INTERNAL_H
#define MPD_DB_INTERNAL_H
#include "db_plugin.h"
#include <assert.h>
static inline void
db_base_init(struct db *db, const struct db_plugin *plugin)
{
assert(plugin != NULL);
db->plugin = plugin;
}
#endif

156
src/db_plugin.h
View File

@ -1,156 +0,0 @@
/*
* Copyright (C) 2003-2011 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.
*/
/** \file
*
* This header declares the db_plugin class. It describes a
* plugin API for databases of song metadata.
*/
#ifndef MPD_DB_PLUGIN_H
#define MPD_DB_PLUGIN_H
#include <glib.h>
#include <assert.h>
#include <stdbool.h>
struct config_param;
struct db_selection;
struct db_visitor;
struct db {
const struct db_plugin *plugin;
};
struct db_plugin {
const char *name;
/**
* Allocates and configures a database.
*/
struct db *(*init)(const struct config_param *param, GError **error_r);
/**
* Free instance data.
*/
void (*finish)(struct db *db);
/**
* Open the database. Read it into memory if applicable.
*/
bool (*open)(struct db *db, GError **error_r);
/**
* Close the database, free allocated memory.
*/
void (*close)(struct db *db);
/**
* Look up a song (including tag data) in the database.
*
* @param the URI of the song within the music directory
* (UTF-8)
*/
struct song *(*get_song)(struct db *db, const char *uri,
GError **error_r);
/**
* Visit the selected entities.
*/
bool (*visit)(struct db *db, const struct db_selection *selection,
const struct db_visitor *visitor, void *ctx,
GError **error_r);
};
G_GNUC_MALLOC
static inline struct db *
db_plugin_new(const struct db_plugin *plugin, const struct config_param *param,
GError **error_r)
{
assert(plugin != NULL);
assert(plugin->init != NULL);
assert(plugin->finish != NULL);
assert(plugin->get_song != NULL);
assert(plugin->visit != NULL);
assert(error_r == NULL || *error_r == NULL);
struct db *db = plugin->init(param, error_r);
assert(db == NULL || db->plugin == plugin);
assert(db != NULL || error_r == NULL || *error_r != NULL);
return db;
}
static inline void
db_plugin_free(struct db *db)
{
assert(db != NULL);
assert(db->plugin != NULL);
assert(db->plugin->finish != NULL);
db->plugin->finish(db);
}
static inline bool
db_plugin_open(struct db *db, GError **error_r)
{
assert(db != NULL);
assert(db->plugin != NULL);
return db->plugin->open != NULL
? db->plugin->open(db, error_r)
: true;
}
static inline void
db_plugin_close(struct db *db)
{
assert(db != NULL);
assert(db->plugin != NULL);
if (db->plugin->close != NULL)
db->plugin->close(db);
}
static inline struct song *
db_plugin_get_song(struct db *db, const char *uri, GError **error_r)
{
assert(db != NULL);
assert(db->plugin != NULL);
assert(db->plugin->get_song != NULL);
assert(uri != NULL);
return db->plugin->get_song(db, uri, error_r);
}
static inline bool
db_plugin_visit(struct db *db, const struct db_selection *selection,
const struct db_visitor *visitor, void *ctx,
GError **error_r)
{
assert(db != NULL);
assert(db->plugin != NULL);
assert(selection != NULL);
assert(visitor != NULL);
assert(error_r == NULL || *error_r == NULL);
return db->plugin->visit(db, selection, visitor, ctx, error_r);
}
#endif

24
src/directory.h
View File

@ -23,6 +23,10 @@
#include "check.h"
#include "util/list.h"
#ifdef __cplusplus
#include "DatabaseVisitor.hxx"
#endif
#include <glib.h>
#include <stdbool.h>
#include <sys/types.h>
@ -86,8 +90,20 @@ struct directory {
dev_t device;
bool have_stat; /* not needed if ino_t == dev_t == 0 is impossible */
char path[sizeof(long)];
#ifdef __cplusplus
/**
* Caller must lock #db_mutex.
*/
bool Walk(bool recursive,
VisitDirectory visit_directory, VisitSong visit_song,
VisitPlaylist visit_playlist,
GError **error_r) const;
#endif
};
G_BEGIN_DECLS
static inline bool
isRootDirectory(const char *name)
{
@ -251,12 +267,6 @@ directory_lookup_song(struct directory *directory, const char *uri);
void
directory_sort(struct directory *directory);
/**
* Caller must lock #db_mutex.
*/
bool
directory_walk(const struct directory *directory, bool recursive,
const struct db_visitor *visitor, void *ctx,
GError **error_r);
G_END_DECLS
#endif