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