db_plugin: convert to C++

10 files changed, 367 insertions, 393 deletions

diff --git a/Makefile.am b/Makefile.am
index 35131a10b..12c76b89c 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -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 \
diff --git a/src/database.c b/src/DatabaseGlue.cxx
index 8c903bb45..551facc47 100644
--- a/src/database.c
+++ b/src/DatabaseGlue.cxx
@@ -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();
 }
diff --git a/src/DatabasePlugin.hxx b/src/DatabasePlugin.hxx
new file mode 100644
index 000000000..45a8c55bf
--- /dev/null
+++ b/src/DatabasePlugin.hxx
@@ -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
diff --git a/src/db/simple_db_plugin.h b/src/DatabaseVisitor.hxx
index 511505846..1676cae19 100644
--- a/src/db/simple_db_plugin.h
+++ b/src/DatabaseVisitor.hxx
@@ -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 <glib.h>
-#include <stdbool.h>
-#include <time.h>
-
-extern const struct db_plugin simple_db_plugin;
+#include <functional>
 
-struct db;
-
-G_GNUC_PURE
-struct directory *
-simple_db_get_root(struct db *db);
+#include <glib.h>
 
-bool
-simple_db_save(struct db *db, GError **error_r);
+struct directory;
+struct song;
+struct playlist_metadata;
 
-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
diff --git a/src/directory.c b/src/Directory.cxx
index e886698d6..91c3596eb 100644
--- a/src/directory.c
+++ b/src/Directory.cxx
@@ -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;
 	}
 
diff --git a/src/db/simple_db_plugin.c b/src/db/SimpleDatabasePlugin.cxx
index 697e8da5f..8398eedc7 100644
--- a/src/db/simple_db_plugin.c
+++ b/src/db/SimpleDatabasePlugin.cxx
@@ -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);
 
-static void
-simple_db_finish(struct db *_db)
-{
-	struct simple_db *db = (struct simple_db *)_db;
-
-	g_free(db->path);
-	g_free(db);
+	return true;
 }
 
-static bool
-simple_db_check(struct simple_db *db, GError **error_r)
+bool
+SimpleDatabase::Check(GError **error_r) const
 {
-	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
+{
+	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 simple_db *db = (const struct simple_db *)_db;
-	const struct directory *directory =
-		simple_db_lookup_directory(db, selection->uri);
+	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,
+};
diff --git a/src/db/SimpleDatabasePlugin.hxx b/src/db/SimpleDatabasePlugin.hxx
new file mode 100644
index 000000000..e2d247385
--- /dev/null
+++ b/src/db/SimpleDatabasePlugin.hxx
@@ -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
diff --git a/src/db_internal.h b/src/db_internal.h
deleted file mode 100644
index a33351524..000000000
--- a/src/db_internal.h
+++ /dev/null
@@ -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
diff --git a/src/db_plugin.h b/src/db_plugin.h
deleted file mode 100644
index 1c7e14ede..000000000
--- a/src/db_plugin.h
+++ /dev/null
@@ -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
diff --git a/src/directory.h b/src/directory.h
index b3cd9c8c9..c7e70121f 100644
--- a/src/directory.h
+++ b/src/directory.h
@@ -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