output/fifo: convert to C++

1 files changed, 110 insertions, 98 deletions

diff --git a/src/output/fifo_output_plugin.c b/src/output/FifoOutputPlugin.cxx
index 3d6171ae2..ebebc254f 100644
--- a/src/output/fifo_output_plugin.c
+++ b/src/output/FifoOutputPlugin.cxx
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2003-2011 The Music Player Daemon Project
+ * Copyright (C) 2003-2013 The Music Player Daemon Project
  * http://www.musicpd.org
  *
  * This program is free software; you can redistribute it and/or modify
@@ -18,7 +18,7 @@
  */
 
 #include "config.h"
-#include "fifo_output_plugin.h"
+#include "FifoOutputPlugin.hxx"
 #include "output_api.h"
 #include "timer.h"
 #include "fd_util.h"
@@ -37,7 +37,7 @@
 
 #define FIFO_BUFFER_SIZE 65536 /* pipe capacity on Linux >= 2.6.11 */
 
-struct fifo_data {
+struct FifoOutput {
 	struct audio_output base;
 
 	char *path;
@@ -45,6 +45,29 @@ struct fifo_data {
 	int output;
 	bool created;
 	struct timer *timer;
+
+	FifoOutput()
+		:path(nullptr), input(-1), output(-1), created(false) {}
+
+	~FifoOutput() {
+		g_free(path);
+	}
+
+	bool Initialize(const config_param *param, GError **error_r) {
+		return ao_base_init(&base, &fifo_output_plugin, param,
+				    error_r);
+	}
+
+	void Deinitialize() {
+		ao_base_finish(&base);
+	}
+
+	bool Create(GError **error_r);
+	bool Check(GError **error_r);
+	void Delete();
+
+	bool Open(GError **error_r);
+	void Close();
 };
 
 /**
@@ -56,156 +79,138 @@ fifo_output_quark(void)
 	return g_quark_from_static_string("fifo_output");
 }
 
-static struct fifo_data *fifo_data_new(void)
-{
-	struct fifo_data *ret;
-
-	ret = g_new(struct fifo_data, 1);
-
-	ret->path = NULL;
-	ret->input = -1;
-	ret->output = -1;
-	ret->created = false;
-
-	return ret;
-}
-
-static void fifo_data_free(struct fifo_data *fd)
+inline void
+FifoOutput::Delete()
 {
-	g_free(fd->path);
-	g_free(fd);
-}
-
-static void fifo_delete(struct fifo_data *fd)
-{
-	g_debug("Removing FIFO \"%s\"", fd->path);
+	g_debug("Removing FIFO \"%s\"", path);
 
-	if (unlink(fd->path) < 0) {
+	if (unlink(path) < 0) {
 		g_warning("Could not remove FIFO \"%s\": %s",
-			  fd->path, g_strerror(errno));
+			  path, g_strerror(errno));
 		return;
 	}
 
-	fd->created = false;
+	created = false;
 }
 
-static void
-fifo_close(struct fifo_data *fd)
+void
+FifoOutput::Close()
 {
 	struct stat st;
 
-	if (fd->input >= 0) {
-		close(fd->input);
-		fd->input = -1;
+	if (input >= 0) {
+		close(input);
+		input = -1;
 	}
 
-	if (fd->output >= 0) {
-		close(fd->output);
-		fd->output = -1;
+	if (output >= 0) {
+		close(output);
+		output = -1;
 	}
 
-	if (fd->created && (stat(fd->path, &st) == 0))
-		fifo_delete(fd);
+	if (created && (stat(path, &st) == 0))
+		Delete();
 }
 
-static bool
-fifo_make(struct fifo_data *fd, GError **error)
+inline bool
+FifoOutput::Create(GError **error_r)
 {
-	if (mkfifo(fd->path, 0666) < 0) {
-		g_set_error(error, fifo_output_quark(), errno,
+	if (mkfifo(path, 0666) < 0) {
+		g_set_error(error_r, fifo_output_quark(), errno,
 			    "Couldn't create FIFO \"%s\": %s",
-			    fd->path, g_strerror(errno));
+			    path, g_strerror(errno));
 		return false;
 	}
 
-	fd->created = true;
-
+	created = true;
 	return true;
 }
 
-static bool
-fifo_check(struct fifo_data *fd, GError **error)
+inline bool
+FifoOutput::Check(GError **error_r)
 {
 	struct stat st;
-
-	if (stat(fd->path, &st) < 0) {
+	if (stat(path, &st) < 0) {
 		if (errno == ENOENT) {
 			/* Path doesn't exist */
-			return fifo_make(fd, error);
+			return Create(error_r);
 		}
 
-		g_set_error(error, fifo_output_quark(), errno,
+		g_set_error(error_r, fifo_output_quark(), errno,
 			    "Failed to stat FIFO \"%s\": %s",
-			    fd->path, g_strerror(errno));
+			    path, g_strerror(errno));
 		return false;
 	}
 
 	if (!S_ISFIFO(st.st_mode)) {
-		g_set_error(error, fifo_output_quark(), 0,
+		g_set_error(error_r, fifo_output_quark(), 0,
 			    "\"%s\" already exists, but is not a FIFO",
-			    fd->path);
+			    path);
 		return false;
 	}
 
 	return true;
 }
 
-static bool
-fifo_open(struct fifo_data *fd, GError **error)
+inline bool
+FifoOutput::Open(GError **error_r)
 {
-	if (!fifo_check(fd, error))
+	if (!Check(error_r))
 		return false;
 
-	fd->input = open_cloexec(fd->path, O_RDONLY|O_NONBLOCK|O_BINARY, 0);
-	if (fd->input < 0) {
-		g_set_error(error, fifo_output_quark(), errno,
+	input = open_cloexec(path, O_RDONLY|O_NONBLOCK|O_BINARY, 0);
+	if (input < 0) {
+		g_set_error(error_r, fifo_output_quark(), errno,
 			    "Could not open FIFO \"%s\" for reading: %s",
-			    fd->path, g_strerror(errno));
-		fifo_close(fd);
+			    path, g_strerror(errno));
+		Close();
 		return false;
 	}
 
-	fd->output = open_cloexec(fd->path, O_WRONLY|O_NONBLOCK|O_BINARY, 0);
-	if (fd->output < 0) {
-		g_set_error(error, fifo_output_quark(), errno,
+	output = open_cloexec(path, O_WRONLY|O_NONBLOCK|O_BINARY, 0);
+	if (output < 0) {
+		g_set_error(error_r, fifo_output_quark(), errno,
 			    "Could not open FIFO \"%s\" for writing: %s",
-			    fd->path, g_strerror(errno));
-		fifo_close(fd);
+			    path, g_strerror(errno));
+		Close();
 		return false;
 	}
 
 	return true;
 }
 
-static struct audio_output *
-fifo_output_init(const struct config_param *param,
-		 GError **error_r)
+static bool
+fifo_open(FifoOutput *fd, GError **error_r)
 {
-	struct fifo_data *fd;
+	return fd->Open(error_r);
+}
 
-	GError *error = NULL;
+static struct audio_output *
+fifo_output_init(const config_param *param, GError **error_r)
+{
+	GError *error = nullptr;
 	char *path = config_dup_block_path(param, "path", &error);
 	if (!path) {
-		if (error != NULL)
+		if (error != nullptr)
 			g_propagate_error(error_r, error);
 		else
 			g_set_error(error_r, fifo_output_quark(), 0,
 				    "No \"path\" parameter specified");
-		return NULL;
+		return nullptr;
 	}
 
-	fd = fifo_data_new();
+	FifoOutput *fd = new FifoOutput();
 	fd->path = path;
 
-	if (!ao_base_init(&fd->base, &fifo_output_plugin, param, error_r)) {
-		fifo_data_free(fd);
-		return NULL;
+	if (!fd->Initialize(param, error_r)) {
+		delete fd;
+		return nullptr;
 	}
 
 	if (!fifo_open(fd, error_r)) {
-		ao_base_finish(&fd->base);
-		fifo_data_free(fd);
-		return NULL;
+		fd->Deinitialize();
+		delete fd;
+		return nullptr;
 	}
 
 	return &fd->base;
@@ -214,18 +219,18 @@ fifo_output_init(const struct config_param *param,
 static void
 fifo_output_finish(struct audio_output *ao)
 {
-	struct fifo_data *fd = (struct fifo_data *)ao;
+	FifoOutput *fd = (FifoOutput *)ao;
 
-	fifo_close(fd);
-	ao_base_finish(&fd->base);
-	fifo_data_free(fd);
+	fd->Close();
+	fd->Deinitialize();
+	delete fd;
 }
 
 static bool
 fifo_output_open(struct audio_output *ao, struct audio_format *audio_format,
 		 G_GNUC_UNUSED GError **error)
 {
-	struct fifo_data *fd = (struct fifo_data *)ao;
+	FifoOutput *fd = (FifoOutput *)ao;
 
 	fd->timer = timer_new(audio_format);
 
@@ -235,7 +240,7 @@ fifo_output_open(struct audio_output *ao, struct audio_format *audio_format,
 static void
 fifo_output_close(struct audio_output *ao)
 {
-	struct fifo_data *fd = (struct fifo_data *)ao;
+	FifoOutput *fd = (FifoOutput *)ao;
 
 	timer_free(fd->timer);
 }
@@ -243,7 +248,7 @@ fifo_output_close(struct audio_output *ao)
 static void
 fifo_output_cancel(struct audio_output *ao)
 {
-	struct fifo_data *fd = (struct fifo_data *)ao;
+	FifoOutput *fd = (FifoOutput *)ao;
 	char buf[FIFO_BUFFER_SIZE];
 	int bytes = 1;
 
@@ -261,7 +266,7 @@ fifo_output_cancel(struct audio_output *ao)
 static unsigned
 fifo_output_delay(struct audio_output *ao)
 {
-	struct fifo_data *fd = (struct fifo_data *)ao;
+	FifoOutput *fd = (FifoOutput *)ao;
 
 	return fd->timer->started
 		? timer_delay(fd->timer)
@@ -272,7 +277,7 @@ static size_t
 fifo_output_play(struct audio_output *ao, const void *chunk, size_t size,
 		 GError **error)
 {
-	struct fifo_data *fd = (struct fifo_data *)ao;
+	FifoOutput *fd = (FifoOutput *)ao;
 	ssize_t bytes;
 
 	if (!fd->timer->started)
@@ -303,12 +308,19 @@ fifo_output_play(struct audio_output *ao, const void *chunk, size_t size,
 }
 
 const struct audio_output_plugin fifo_output_plugin = {
-	.name = "fifo",
-	.init = fifo_output_init,
-	.finish = fifo_output_finish,
-	.open = fifo_output_open,
-	.close = fifo_output_close,
-	.delay = fifo_output_delay,
-	.play = fifo_output_play,
-	.cancel = fifo_output_cancel,
+	"fifo",
+	nullptr,
+	fifo_output_init,
+	fifo_output_finish,
+	nullptr,
+	nullptr,
+	fifo_output_open,
+	fifo_output_close,
+	fifo_output_delay,
+	nullptr,
+	fifo_output_play,
+	nullptr,
+	fifo_output_cancel,
+	nullptr,
+	nullptr,
 };