12 files changed, 544 insertions, 167 deletions

diff --git a/src/util/ConstBuffer.hxx b/src/util/ConstBuffer.hxx
new file mode 100644
index 000000000..bd3c405e5
--- /dev/null
+++ b/src/util/ConstBuffer.hxx
@@ -0,0 +1,118 @@
+/*
+ * Copyright (C) 2013 Max Kellermann <max@duempel.org>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the
+ * distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
+ * FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef CONST_BUFFER_HPP
+#define CONST_BUFFER_HPP
+
+#include "Compiler.h"
+
+#include <cstddef>
+
+#ifndef NDEBUG
+#include <assert.h>
+#endif
+
+/**
+ * A reference to a memory area that is read-only.
+ */
+template<typename T>
+struct ConstBuffer {
+	typedef size_t size_type;
+	typedef const T *pointer_type;
+	typedef pointer_type const_pointer_type;
+	typedef pointer_type iterator;
+	typedef pointer_type const_iterator;
+
+	pointer_type data;
+	size_type size;
+
+	ConstBuffer() = default;
+
+	constexpr ConstBuffer(std::nullptr_t):data(nullptr), size(0) {}
+
+	constexpr ConstBuffer(pointer_type _data, size_type _size)
+		:data(_data), size(_size) {}
+
+	constexpr static ConstBuffer Null() {
+		return ConstBuffer(nullptr, 0);
+	}
+
+	/**
+	 * Cast a ConstBuffer<void> to a ConstBuffer<T>.  A "void"
+	 * buffer records its size in bytes, and when casting to "T",
+	 * the assertion below ensures that the size is a multiple of
+	 * sizeof(T).
+	 */
+#ifdef NDEBUG
+	constexpr
+#endif
+	static ConstBuffer<T> FromVoid(ConstBuffer<void> other) {
+		static_assert(sizeof(T) > 0, "Empty base type");
+#ifndef NDEBUG
+		assert(other.size % sizeof(T) == 0);
+#endif
+		return ConstBuffer<T>(pointer_type(other.data),
+				      other.size / sizeof(T));
+	}
+
+	constexpr ConstBuffer<void> ToVoid() const {
+		static_assert(sizeof(T) > 0, "Empty base type");
+		return ConstBuffer<void>(data, size * sizeof(T));
+	}
+
+	constexpr bool IsNull() const {
+		return data == nullptr;
+	}
+
+	constexpr bool IsEmpty() const {
+		return size == 0;
+	}
+
+	constexpr iterator begin() const {
+		return data;
+	}
+
+	constexpr iterator end() const {
+		return data + size;
+	}
+
+	constexpr const_iterator cbegin() const {
+		return data;
+	}
+
+	constexpr const_iterator cend() const {
+		return data + size;
+	}
+
+	constexpr operator ConstBuffer<void>() const {
+		return { data, size };
+	}
+};
+
+#endif
diff --git a/src/util/DynamicFifoBuffer.hxx b/src/util/DynamicFifoBuffer.hxx
new file mode 100644
index 000000000..ead7389e9
--- /dev/null
+++ b/src/util/DynamicFifoBuffer.hxx
@@ -0,0 +1,199 @@
+/*
+ * Copyright (C) 2003-2013 Max Kellermann <max@duempel.org>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the
+ * distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
+ * FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef FIFO_BUFFER_HPP
+#define FIFO_BUFFER_HPP
+
+#include "WritableBuffer.hxx"
+
+#include <utility>
+#include <algorithm>
+
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
+
+/**
+ * A first-in-first-out buffer: you can append data at the end, and
+ * read data from the beginning.  This class automatically shifts the
+ * buffer as needed.  It is not thread safe.
+ */
+template<typename T>
+class DynamicFifoBuffer {
+public:
+	typedef size_t size_type;
+	typedef WritableBuffer<T> Range;
+	typedef typename Range::pointer_type pointer_type;
+	typedef typename Range::const_pointer_type const_pointer_type;
+
+protected:
+	size_type head, tail, capacity;
+	T *data;
+
+public:
+	DynamicFifoBuffer(size_type _capacity)
+		:head(0), tail(0), capacity(_capacity),
+		 data(new T[capacity]) {}
+	~DynamicFifoBuffer() {
+		delete[] data;
+	}
+
+	DynamicFifoBuffer(const DynamicFifoBuffer &) = delete;
+
+	size_type GetCapacity() {
+		return capacity;
+	}
+
+	void Grow(size_type new_capacity) {
+		assert(new_capacity > capacity);
+
+		T *new_data = new T[new_capacity];
+		std::move(data + head, data + tail, new_data);
+		delete[] data;
+		data = new_data;
+		capacity = new_capacity;
+		tail -= head;
+		head = 0;
+	}
+
+	void Clear() {
+		head = tail = 0;
+	}
+
+	bool IsEmpty() const {
+		return head == tail;
+	}
+
+	bool IsFull() const {
+		return head == 0 && tail == capacity;
+	}
+
+	/**
+	 * Prepares writing.  Returns a buffer range which may be written.
+	 * When you are finished, call append().
+	 */
+	Range Write() {
+		Shift();
+		return Range(data + tail, capacity - tail);
+	}
+
+	/**
+	 * Expands the tail of the buffer, after data has been written to
+	 * the buffer returned by write().
+	 */
+	void Append(size_type n) {
+		assert(tail <= capacity);
+		assert(n <= capacity);
+		assert(tail + n <= capacity);
+
+		tail += n;
+	}
+
+	void WantWrite(size_type n) {
+		if (tail + n <= capacity)
+			/* enough space after the tail */
+			return;
+
+		const size_type in_use = tail - head;
+		const size_type required_capacity = in_use + n;
+		if (capacity >= required_capacity) {
+			Shift();
+		} else {
+			size_type new_capacity = capacity;
+			do {
+				new_capacity <<= 1;
+			} while (new_capacity < required_capacity);
+
+			Grow(new_capacity);
+		}
+	}
+
+	/**
+	 * Write data to the bfufer, growing it as needed.  Returns a
+	 * writable pointer.
+	 */
+	pointer_type Write(size_type n) {
+		WantWrite(n);
+		return data + tail;
+	}
+
+	/**
+	 * Append data to the buffer, growing it as needed.
+	 */
+	void Append(const_pointer_type p, size_type n) {
+		std::copy_n(p, n, Write(n));
+		Append(n);
+	}
+
+	/**
+	 * Return a buffer range which may be read.  The buffer pointer is
+	 * writable, to allow modifications while parsing.
+	 */
+	Range Read() {
+		return Range(data + head, tail - head);
+	}
+
+	/**
+	 * Marks a chunk as consumed.
+	 */
+	void Consume(size_type n) {
+		assert(tail <= capacity);
+		assert(head <= tail);
+		assert(n <= tail);
+		assert(head + n <= tail);
+
+		head += n;
+	}
+
+	size_type Read(pointer_type p, size_type n) {
+		auto range = Read();
+		if (n > range.size)
+			n = range.size;
+		std::copy_n(range.data, n, p);
+		Consume(n);
+		return n;
+	}
+
+protected:
+	void Shift() {
+		if (head == 0)
+			return;
+
+		assert(head <= capacity);
+		assert(tail <= capacity);
+		assert(tail >= head);
+
+		std::move(data + head, data + tail, data);
+
+		tail -= head;
+		head = 0;
+	}
+};
+
+#endif
diff --git a/src/util/Error.hxx b/src/util/Error.hxx
index facb461dc..aa704d593 100644
--- a/src/util/Error.hxx
+++ b/src/util/Error.hxx
@@ -24,6 +24,7 @@
 #include "Compiler.h"
 
 #include <string>
+#include <utility>
 
 #include <assert.h>
 
diff --git a/src/util/FormatString.cxx b/src/util/FormatString.cxx
index c13d0fb52..ea6d41860 100644
--- a/src/util/FormatString.cxx
+++ b/src/util/FormatString.cxx
@@ -19,10 +19,13 @@
 
 #include "FormatString.hxx"
 
-#include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
 
+#ifdef WIN32
+#include <string.h>
+#endif
+
 char *
 FormatNewV(const char *fmt, va_list args)
 {
diff --git a/src/util/OptionDef.hxx b/src/util/OptionDef.hxx
new file mode 100644
index 000000000..ca9e6083f
--- /dev/null
+++ b/src/util/OptionDef.hxx
@@ -0,0 +1,63 @@
+/*
+ * 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
+ * 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_UTIL_OPTIONDEF_HXX
+#define MPD_UTIL_OPTIONDEF_HXX
+
+/**
+ * Command line option definition.
+ */
+class OptionDef
+{
+	const char *long_option;
+	char short_option;
+	const char *desc;
+public:
+	constexpr OptionDef(const char *_long_option, const char *_desc)
+		: long_option(_long_option),
+		  short_option(0),
+		  desc(_desc) { }
+
+	constexpr OptionDef(const char *_long_option,
+			    char _short_option, const char *_desc)
+		: long_option(_long_option),
+		  short_option(_short_option),
+		  desc(_desc) { }
+
+	bool HasLongOption() const { return long_option != nullptr; }
+	bool HasShortOption() const { return short_option != 0; }
+	bool HasDescription() const { return desc != nullptr; }
+
+	const char *GetLongOption() const {
+		assert(HasLongOption());
+		return long_option;
+	}
+
+	char GetShortOption() const {
+		assert(HasShortOption());
+		return short_option;
+	}
+
+	const char *GetDescription() const {
+		assert(HasDescription());
+		return desc;
+	}
+};
+
+#endif
diff --git a/src/util/OptionParser.cxx b/src/util/OptionParser.cxx
new file mode 100644
index 000000000..b8addb9a2
--- /dev/null
+++ b/src/util/OptionParser.cxx
@@ -0,0 +1,59 @@
+/*
+ * 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
+ * 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.
+ */
+
+#include "OptionParser.hxx"
+#include "OptionDef.hxx"
+
+#include <string.h>
+
+bool OptionParser::CheckOption(const OptionDef &opt)
+{
+	assert(option != nullptr);
+
+	if (is_long)
+		return opt.HasLongOption() &&
+		       strcmp(option, opt.GetLongOption()) == 0;
+
+	return opt.HasShortOption() &&
+	       option[0] == opt.GetShortOption() &&
+	       option[1] == '\0';
+}
+
+bool OptionParser::ParseNext()
+{
+	assert(HasEntries());
+	char *arg = *argv;
+	++argv;
+	--argc;
+	if (arg[0] == '-') {
+		if (arg[1] == '-') {
+			option = arg + 2;
+			is_long = true;
+		}
+		else {
+			option = arg + 1;
+			is_long = false;
+		}
+		option_raw = arg;
+		return true;
+	}
+	option = nullptr;
+	option_raw = nullptr;
+	return false;
+}
diff --git a/src/util/OptionParser.hxx b/src/util/OptionParser.hxx
new file mode 100644
index 000000000..74091bc29
--- /dev/null
+++ b/src/util/OptionParser.hxx
@@ -0,0 +1,88 @@
+/*
+ * 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
+ * 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_UTIL_OPTIONPARSER_HXX
+#define MPD_UTIL_OPTIONPARSER_HXX
+
+#include <assert.h>
+
+class OptionDef;
+
+/**
+ * Command line option parser.
+ */
+class OptionParser
+{
+	int argc;
+	char **argv;
+	char *option;
+	char *option_raw;
+	bool is_long;
+public:
+	/**
+	 * Constructs #OptionParser.
+	 */
+	OptionParser(int _argc, char **_argv)
+		: argc(_argc - 1), argv(_argv + 1),
+		  option(nullptr), option_raw(nullptr), is_long(false) { }
+
+	/**
+	 * Checks if there are command line entries to process.
+	 */
+	bool HasEntries() const { return argc > 0; }
+
+	/**
+	 * Gets the last parsed option.
+	 */
+	char *GetOption() {
+		assert(option_raw != nullptr);
+		return option_raw;
+	}
+
+	/**
+	 * Checks if current option is a specified option.
+	 */
+	bool CheckOption(const OptionDef& opt);
+
+	/**
+	 * Checks if current option is a specified option
+	 * or specified alternative option.
+	 */
+	bool CheckOption(const OptionDef& opt, const OptionDef &alt_opt) {
+		return CheckOption(opt) || CheckOption(alt_opt);
+	}
+
+	/**
+	 * Parses current command line entry.
+	 * Returns true on success, false otherwise.
+	 * Regardless of result, advances current position to the next
+	 * command line entry. 
+	 */
+	bool ParseNext();
+
+	/**
+	 * Checks if specified string is a command line option.
+	 */
+	static bool IsOption(const char *s) {
+		assert(s != nullptr);
+		return s[0] == '-';
+	}
+};
+
+#endif
diff --git a/src/util/StringUtil.cxx b/src/util/StringUtil.cxx
index 7e295bf90..512a75f5c 100644
--- a/src/util/StringUtil.cxx
+++ b/src/util/StringUtil.cxx
@@ -22,6 +22,7 @@
 #include "ASCII.hxx"
 
 #include <assert.h>
+#include <string.h>
 
 const char *
 strchug_fast(const char *p)
@@ -33,6 +34,13 @@ strchug_fast(const char *p)
 }
 
 bool
+StringStartsWith(const char *haystack, const char *needle)
+{
+	const size_t length = strlen(needle);
+	return memcmp(haystack, needle, length) == 0;
+}
+
+bool
 string_array_contains(const char *const* haystack, const char *needle)
 {
 	assert(haystack != nullptr);
diff --git a/src/util/StringUtil.hxx b/src/util/StringUtil.hxx
index 1c67910a9..f25160107 100644
--- a/src/util/StringUtil.hxx
+++ b/src/util/StringUtil.hxx
@@ -40,6 +40,10 @@ strchug_fast(char *p)
 	return const_cast<char *>(strchug_fast((const char *)p));
 }
 
+gcc_pure
+bool
+StringStartsWith(const char *haystack, const char *needle);
+
 /**
  * Checks whether a string array contains the specified string.
  *
diff --git a/src/util/Tokenizer.cxx b/src/util/Tokenizer.cxx
index 1c8af23fd..c9eb3949e 100644
--- a/src/util/Tokenizer.cxx
+++ b/src/util/Tokenizer.cxx
@@ -26,9 +26,6 @@
 
 #include <glib.h>
 
-#include <assert.h>
-#include <string.h>
-
 static constexpr Domain tokenizer_domain("tokenizer");
 
 static inline bool
diff --git a/src/util/growing_fifo.c b/src/util/growing_fifo.c
deleted file mode 100644
index 88431f60e..000000000
--- a/src/util/growing_fifo.c
+++ /dev/null
@@ -1,90 +0,0 @@
-/*
- * Copyright (C) 2003-2011 The Music Player Daemon Project
- * http://www.musicpd.org
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * - Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *
- * - Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the
- * distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
- * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
- * FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
- * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
- * OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include "growing_fifo.h"
-#include "fifo_buffer.h"
-
-#include <assert.h>
-#include <string.h>
-
-/**
- * Align buffer sizes at 8 kB boundaries.  Must be a power of two.
- */
-static const size_t GROWING_FIFO_ALIGN = 8192;
-
-/**
- * Align the specified size to the next #GROWING_FIFO_ALIGN boundary.
- */
-static size_t
-align(size_t size)
-{
-	return ((size - 1) | (GROWING_FIFO_ALIGN - 1)) + 1;
-}
-
-struct fifo_buffer *
-growing_fifo_new(void)
-{
-	return fifo_buffer_new(GROWING_FIFO_ALIGN);
-}
-
-void *
-growing_fifo_write(struct fifo_buffer **buffer_p, size_t length)
-{
-	assert(buffer_p != NULL);
-
-	struct fifo_buffer *buffer = *buffer_p;
-	assert(buffer != NULL);
-
-	size_t max_length;
-	void *p = fifo_buffer_write(buffer, &max_length);
-	if (p != NULL && max_length >= length)
-		return p;
-
-	/* grow */
-	size_t new_size = fifo_buffer_available(buffer) + length;
-	assert(new_size > fifo_buffer_capacity(buffer));
-	*buffer_p = buffer = fifo_buffer_realloc(buffer, align(new_size));
-
-	/* try again */
-	p = fifo_buffer_write(buffer, &max_length);
-	assert(p != NULL);
-	assert(max_length >= length);
-
-	return p;
-}
-
-void
-growing_fifo_append(struct fifo_buffer **buffer_p,
-		    const void *data, size_t length)
-{
-	void *p = growing_fifo_write(buffer_p, length);
-	memcpy(p, data, length);
-	fifo_buffer_append(*buffer_p, length);
-}
diff --git a/src/util/growing_fifo.h b/src/util/growing_fifo.h
deleted file mode 100644
index 723c3b3ff..000000000
--- a/src/util/growing_fifo.h
+++ /dev/null
@@ -1,73 +0,0 @@
-/*
- * Copyright (C) 2003-2011 The Music Player Daemon Project
- * http://www.musicpd.org
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * - Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *
- * - Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the
- * distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
- * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
- * FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
- * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
- * OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-/** \file
- *
- * Helper functions for our FIFO buffer library (fifo_buffer.h) that
- * allows growing the buffer on demand.
- *
- * This library is not thread safe.
- */
-
-#ifndef MPD_GROWING_FIFO_H
-#define MPD_GROWING_FIFO_H
-
-#include <stddef.h>
-
-struct fifo_buffer;
-
-/**
- * Allocate a new #fifo_buffer with the default size.
- */
-struct fifo_buffer *
-growing_fifo_new(void);
-
-/**
- * Prepares writing to the buffer, see fifo_buffer_write() for
- * details.  The difference is that this function will automatically
- * grow the buffer if it is too small.
- *
- * The caller is responsible for limiting the capacity of the buffer.
- *
- * @param length the number of bytes that will be written
- * @return a pointer to the end of the buffer (will not be NULL)
- */
-void *
-growing_fifo_write(struct fifo_buffer **buffer_p, size_t length);
-
-/**
- * A helper function that combines growing_fifo_write(), memcpy(),
- * fifo_buffer_append().
- */
-void
-growing_fifo_append(struct fifo_buffer **buffer_p,
-		    const void *data, size_t length);
-
-#endif