queue: convert all functions to methods

src/Playlist.cxx

@@ -36,7 +36,7 @@ extern "C" {
 void
 playlist_increment_version_all(struct playlist *playlist)
 {
-	queue_modify_all(&playlist->queue);
+	playlist->queue.ModifyAll();
 	idle_add(IDLE_PLAYLIST);
 }
 
@@ -48,7 +48,7 @@ playlist_tag_changed(struct playlist *playlist)
 
 	assert(playlist->current >= 0);
 
-	queue_modify(&playlist->queue, playlist->current);
+	playlist->queue.ModifyAtOrder(playlist->current);
 	idle_add(IDLE_PLAYLIST);
 }
 
@@ -61,12 +61,12 @@ playlist_queue_song_order(struct playlist *playlist, struct player_control *pc,
 {
 	char *uri;
 
-	assert(queue_valid_order(&playlist->queue, order));
+	assert(playlist->queue.IsValidOrder(order));
 
 	playlist->queued = order;
 
 	struct song *song =
-		song_dup_detached(queue_get_order(&playlist->queue, order));
+		song_dup_detached(playlist->queue.GetOrder(order));
 
 	uri = song_get_uri(song);
 	g_debug("queue song %i:\"%s\"", playlist->queued, uri);
@@ -93,8 +93,7 @@ playlist_song_started(struct playlist *playlist, struct player_control *pc)
 
 	if(playlist->queue.consume)
 		playlist_delete(playlist, pc,
-				queue_order_to_position(&playlist->queue,
-							current));
+				playlist->queue.OrderToPosition(current));
 
 	idle_add(IDLE_PLAYER);
 }
@@ -105,7 +104,7 @@ playlist_get_queued_song(struct playlist *playlist)
 	if (!playlist->playing || playlist->queued < 0)
 		return NULL;
 
-	return queue_get_order(&playlist->queue, playlist->queued);
+	return playlist->queue.GetOrder(playlist->queued);
 }
 
 void
@@ -119,11 +118,11 @@ playlist_update_queued_song(struct playlist *playlist,
 	if (!playlist->playing)
 		return;
 
-	assert(!queue_is_empty(&playlist->queue));
+	assert(!playlist->queue.IsEmpty());
 	assert((playlist->queued < 0) == (prev == NULL));
 
 	next_order = playlist->current >= 0
-		? queue_next_order(&playlist->queue, playlist->current)
+		? playlist->queue.GetNextOrder(playlist->current)
 		: 0;
 
 	if (next_order == 0 && playlist->queue.random &&
@@ -132,21 +131,19 @@ playlist_update_queued_song(struct playlist *playlist,
 		   order each time the playlist is played
 		   completely */
 		unsigned current_position =
-			queue_order_to_position(&playlist->queue,
-						playlist->current);
+			playlist->queue.OrderToPosition(playlist->current);
 
-		queue_shuffle_order(&playlist->queue);
+		playlist->queue.ShuffleOrder();
 
 		/* make sure that the playlist->current still points to
 		   the current song, after the song order has been
 		   shuffled */
 		playlist->current =
-			queue_position_to_order(&playlist->queue,
-						current_position);
+			playlist->queue.PositionToOrder(current_position);
 	}
 
 	if (next_order >= 0)
-		next_song = queue_get_order(&playlist->queue, next_order);
+		next_song = playlist->queue.GetOrder(next_order);
 	else
 		next_song = NULL;
 
@@ -174,7 +171,7 @@ playlist_play_order(struct playlist *playlist, struct player_control *pc,
 	playlist->queued = -1;
 
 	struct song *song =
-		song_dup_detached(queue_get_order(&playlist->queue, orderNum));
+		song_dup_detached(playlist->queue.GetOrder(orderNum));
 
 	uri = song_get_uri(song);
 	g_debug("play %i:\"%s\"", orderNum, uri);
@@ -247,7 +244,7 @@ playlist_resume_playback(struct playlist *playlist, struct player_control *pc)
 
 	if ((playlist->stop_on_error && error != PLAYER_ERROR_NONE) ||
 	    error == PLAYER_ERROR_OUTPUT ||
-	    playlist->error_count >= queue_length(&playlist->queue))
+	    playlist->error_count >= playlist->queue.GetLength())
 		/* too many errors, or critical error: stop
 		   playback */
 		playlist_stop(playlist, pc);
@@ -306,10 +303,9 @@ playlist_order(struct playlist *playlist)
 {
 	if (playlist->current >= 0)
 		/* update playlist.current, order==position now */
-		playlist->current = queue_order_to_position(&playlist->queue,
-							    playlist->current);
+		playlist->current = playlist->queue.OrderToPosition(playlist->current);
 
-	queue_restore_order(&playlist->queue);
+	playlist->queue.RestoreOrder();
 }
 
 void
@@ -362,20 +358,18 @@ playlist_set_random(struct playlist *playlist, struct player_control *pc,
 
 		int current_position =
 			playlist->playing && playlist->current >= 0
-			? (int)queue_order_to_position(&playlist->queue,
-						       playlist->current)
+			? (int)playlist->queue.OrderToPosition(playlist->current)
 			: -1;
 
-		queue_shuffle_order(&playlist->queue);
+		playlist->queue.ShuffleOrder();
 
 		if (current_position >= 0) {
 			/* make sure the current song is the first in
 			   the order list, so the whole rest of the
 			   playlist is played after that */
 			unsigned current_order =
-				queue_position_to_order(&playlist->queue,
-							current_position);
-			queue_swap_order(&playlist->queue, 0, current_order);
+				playlist->queue.PositionToOrder(current_position);
+			playlist->queue.SwapOrders(0, current_order);
 			playlist->current = 0;
 		} else
 			playlist->current = -1;
@@ -391,8 +385,7 @@ int
 playlist_get_current_song(const struct playlist *playlist)
 {
 	if (playlist->current >= 0)
-		return queue_order_to_position(&playlist->queue,
-					       playlist->current);
+		return playlist->queue.OrderToPosition(playlist->current);
 
 	return -1;
 }
@@ -403,13 +396,11 @@ playlist_get_next_song(const struct playlist *playlist)
 	if (playlist->current >= 0)
 	{
 		if (playlist->queue.single == 1 && playlist->queue.repeat == 1)
-			return queue_order_to_position(&playlist->queue,
-			                               playlist->current);
-		else if (playlist->current + 1 < (int)queue_length(&playlist->queue))
-			return queue_order_to_position(&playlist->queue,
-					       playlist->current + 1);
+			return playlist->queue.OrderToPosition(playlist->current);
+		else if (playlist->current + 1 < (int)playlist->queue.GetLength())
+			return playlist->queue.OrderToPosition(playlist->current + 1);
 		else if (playlist->queue.repeat == 1)
-			return queue_order_to_position(&playlist->queue, 0);
+			return playlist->queue.OrderToPosition(0);
 	}
 
 	return -1;
@@ -424,11 +415,11 @@ playlist_get_version(const struct playlist *playlist)
 int
 playlist_get_length(const struct playlist *playlist)
 {
-	return queue_length(&playlist->queue);
+	return playlist->queue.GetLength();
 }
 
 unsigned
 playlist_get_song_id(const struct playlist *playlist, unsigned song)
 {
-	return queue_position_to_id(&playlist->queue, song);
+	return playlist->queue.PositionToId(song);
 }

src/PlaylistControl.cxx

@@ -50,16 +50,14 @@ playlist_stop(struct playlist *playlist, struct player_control *pc)
 		   result in a new random order */
 
 		unsigned current_position =
-			queue_order_to_position(&playlist->queue,
-						playlist->current);
+			playlist->queue.OrderToPosition(playlist->current);
 
-		queue_shuffle_order(&playlist->queue);
+		playlist->queue.ShuffleOrder();
 
 		/* make sure that "current" stays valid, and the next
 		   "play" command plays the same song again */
 		playlist->current =
-			queue_position_to_order(&playlist->queue,
-						current_position);
+			playlist->queue.PositionToOrder(current_position);
 	}
 }
 
@@ -74,7 +72,7 @@ playlist_play(struct playlist *playlist, struct player_control *pc,
 	if (song == -1) {
 		/* play any song ("current" song, or the first song */
 
-		if (queue_is_empty(&playlist->queue))
+		if (playlist->queue.IsEmpty())
 			return PLAYLIST_RESULT_SUCCESS;
 
 		if (playlist->playing) {
@@ -88,7 +86,7 @@ playlist_play(struct playlist *playlist, struct player_control *pc,
 		i = playlist->current >= 0
 			? playlist->current
 			: 0;
-	} else if (!queue_valid_position(&playlist->queue, song))
+	} else if (!playlist->queue.IsValidPosition(song))
 		return PLAYLIST_RESULT_BAD_RANGE;
 
 	if (playlist->queue.random) {
@@ -97,15 +95,14 @@ playlist_play(struct playlist *playlist, struct player_control *pc,
 			   would be equal to the order number in
 			   no-random mode); convert it to a order
 			   number, because random mode is enabled */
-			i = queue_position_to_order(&playlist->queue, song);
+			i = playlist->queue.PositionToOrder(song);
 
 		if (!playlist->playing)
 			playlist->current = 0;
 
 		/* swap the new song with the previous "current" one,
 		   so playback continues as planned */
-		queue_swap_order(&playlist->queue,
-				 i, playlist->current);
+		playlist->queue.SwapOrders(i, playlist->current);
 		i = playlist->current;
 	}
 
@@ -126,7 +123,7 @@ playlist_play_id(struct playlist *playlist, struct player_control *pc,
 		return playlist_play(playlist, pc, id);
 	}
 
-	song = queue_id_to_position(&playlist->queue, id);
+	song = playlist->queue.IdToPosition(id);
 	if (song < 0)
 		return PLAYLIST_RESULT_NO_SUCH_SONG;
 
@@ -142,15 +139,15 @@ playlist_next(struct playlist *playlist, struct player_control *pc)
 	if (!playlist->playing)
 		return;
 
-	assert(!queue_is_empty(&playlist->queue));
-	assert(queue_valid_order(&playlist->queue, playlist->current));
+	assert(!playlist->queue.IsEmpty());
+	assert(playlist->queue.IsValidOrder(playlist->current));
 
 	current = playlist->current;
 	playlist->stop_on_error = false;
 
 	/* determine the next song from the queue's order list */
 
-	next_order = queue_next_order(&playlist->queue, playlist->current);
+	next_order = playlist->queue.GetNextOrder(playlist->current);
 	if (next_order < 0) {
 		/* no song after this one: stop playback */
 		playlist_stop(playlist, pc);
@@ -167,7 +164,7 @@ playlist_next(struct playlist *playlist, struct player_control *pc)
 			   songs in a different than before */
 			assert(playlist->queue.repeat);
 
-			queue_shuffle_order(&playlist->queue);
+			playlist->queue.ShuffleOrder();
 
 			/* note that playlist->current and playlist->queued are
 			   now invalid, but playlist_play_order() will
@@ -180,8 +177,7 @@ playlist_next(struct playlist *playlist, struct player_control *pc)
 	/* Consume mode removes each played songs. */
 	if(playlist->queue.consume)
 		playlist_delete(playlist, pc,
-				queue_order_to_position(&playlist->queue,
-							current));
+				playlist->queue.OrderToPosition(current));
 }
 
 void
@@ -190,7 +186,7 @@ playlist_previous(struct playlist *playlist, struct player_control *pc)
 	if (!playlist->playing)
 		return;
 
-	assert(queue_length(&playlist->queue) > 0);
+	assert(playlist->queue.GetLength() > 0);
 
 	if (playlist->current > 0) {
 		/* play the preceding song */
@@ -199,7 +195,7 @@ playlist_previous(struct playlist *playlist, struct player_control *pc)
 	} else if (playlist->queue.repeat) {
 		/* play the last song in "repeat" mode */
 		playlist_play_order(playlist, pc,
-				    queue_length(&playlist->queue) - 1);
+				    playlist->queue.GetLength() - 1);
 	} else {
 		/* re-start playing the current song if it's
 		   the first one */
@@ -215,13 +211,13 @@ playlist_seek_song(struct playlist *playlist, struct player_control *pc,
 	unsigned i;
 	bool success;
 
-	if (!queue_valid_position(&playlist->queue, song))
+	if (!playlist->queue.IsValidPosition(song))
 		return PLAYLIST_RESULT_BAD_RANGE;
 
 	queued = playlist_get_queued_song(playlist);
 
 	if (playlist->queue.random)
-		i = queue_position_to_order(&playlist->queue, song);
+		i = playlist->queue.PositionToOrder(song);
 	else
 		i = song;
 
@@ -240,7 +236,7 @@ playlist_seek_song(struct playlist *playlist, struct player_control *pc,
 	}
 
 	struct song *the_song =
-		song_dup_detached(queue_get_order(&playlist->queue, i));
+		song_dup_detached(playlist->queue.GetOrder(i));
 	success = pc_seek(pc, the_song, seek_time);
 	if (!success) {
 		playlist_update_queued_song(playlist, pc, queued);
@@ -258,7 +254,7 @@ enum playlist_result
 playlist_seek_song_id(struct playlist *playlist, struct player_control *pc,
 		      unsigned id, float seek_time)
 {
-	int song = queue_id_to_position(&playlist->queue, id);
+	int song = playlist->queue.IdToPosition(id);
 	if (song < 0)
 		return PLAYLIST_RESULT_NO_SUCH_SONG;
 

src/PlaylistPrint.cxx

@@ -41,7 +41,7 @@ playlist_print_uris(Client *client, const struct playlist *playlist)
 {
 	const struct queue *queue = &playlist->queue;
 
-	queue_print_uris(client, queue, 0, queue_length(queue));
+	queue_print_uris(client, queue, 0, queue->GetLength());
 }
 
 bool
@@ -50,9 +50,9 @@ playlist_print_info(Client *client, const struct playlist *playlist,
 {
 	const struct queue *queue = &playlist->queue;
 
-	if (end > queue_length(queue))
+	if (end > queue->GetLength())
 		/* correct the "end" offset */
-		end = queue_length(queue);
+		end = queue->GetLength();
 
 	if (start > end)
 		/* an invalid "start" offset is fatal */
@@ -69,7 +69,7 @@ playlist_print_id(Client *client, const struct playlist *playlist,
 	const struct queue *queue = &playlist->queue;
 	int position;
 
-	position = queue_id_to_position(queue, id);
+	position = queue->IdToPosition(id);
 	if (position < 0)
 		/* no such song */
 		return false;

src/PlaylistSave.cxx

@@ -98,8 +98,8 @@ spl_save_queue(const char *name_utf8, const struct queue *queue)
 	if (file == NULL)
 		return PLAYLIST_RESULT_ERRNO;
 
-	for (unsigned i = 0; i < queue_length(queue); i++)
-		playlist_print_song(file, queue_get(queue, i));
+	for (unsigned i = 0; i < queue->GetLength(); i++)
+		playlist_print_song(file, queue->Get(i));
 
 	fclose(file);
 

src/PlaylistState.cxx

@@ -74,8 +74,7 @@ playlist_state_save(FILE *fp, const struct playlist *playlist,
 			fputs(PLAYLIST_STATE_FILE_STATE_PLAY "\n", fp);
 		}
 		fprintf(fp, PLAYLIST_STATE_FILE_CURRENT "%i\n",
-			queue_order_to_position(&playlist->queue,
-						playlist->current));
+			playlist->queue.OrderToPosition(playlist->current));
 		fprintf(fp, PLAYLIST_STATE_FILE_TIME "%i\n",
 			(int)player_status.elapsed_time);
 	} else {
@@ -83,8 +82,7 @@ playlist_state_save(FILE *fp, const struct playlist *playlist,
 
 		if (playlist->current >= 0)
 			fprintf(fp, PLAYLIST_STATE_FILE_CURRENT "%i\n",
-				queue_order_to_position(&playlist->queue,
-							playlist->current));
+				playlist->queue.OrderToPosition(playlist->current));
 	}
 
 	fprintf(fp, PLAYLIST_STATE_FILE_RANDOM "%i\n", playlist->queue.random);
@@ -123,7 +121,7 @@ playlist_state_load(TextFile &file, struct playlist *playlist)
 		}
 	}
 
-	queue_increment_version(&playlist->queue);
+	playlist->queue.IncrementVersion();
 }
 
 bool
@@ -195,8 +193,8 @@ playlist_state_restore(const char *line, TextFile &file,
 
 	playlist_set_random(playlist, pc, random_mode);
 
-	if (!queue_is_empty(&playlist->queue)) {
-		if (!queue_valid_position(&playlist->queue, current))
+	if (!playlist->queue.IsEmpty()) {
+		if (!playlist->queue.IsValidPosition(current))
 			current = 0;
 
 		if (state == PLAYER_STATE_PLAY &&
@@ -239,8 +237,7 @@ playlist_state_get_hash(const struct playlist *playlist,
 		 ? ((int)player_status.elapsed_time << 8)
 		 : 0) ^
 		(playlist->current >= 0
-		 ? (queue_order_to_position(&playlist->queue,
-					    playlist->current) << 16)
+		 ? (playlist->queue.OrderToPosition(playlist->current) << 16)
 		 : 0) ^
 		((int)pc_get_cross_fade(pc) << 20) ^
 		(player_status.state << 24) ^

src/Queue.hxx

@@ -20,10 +20,11 @@
 #ifndef MPD_QUEUE_HXX
 #define MPD_QUEUE_HXX
 
+#include "gcc.h"
+
 #include <glib.h>
 
 #include <assert.h>
-#include <stdbool.h>
 #include <stdint.h>
 
 enum {
@@ -110,169 +111,141 @@ struct queue {
 
 	queue(const queue &other) = delete;
 	queue &operator=(const queue &other) = delete;
-};
 
-static inline unsigned
-queue_length(const struct queue *queue)
-{
-	assert(queue->length <= queue->max_length);
+	unsigned GetLength() const {
+		assert(length <= max_length);
 
-	return queue->length;
-}
+		return length;
+	}
 
-/**
+	/**
 	 * Determine if the queue is empty, i.e. there are no songs.
 	 */
-static inline bool
-queue_is_empty(const struct queue *queue)
-{
-	return queue->length == 0;
-}
+	bool IsEmpty() const {
+		return length == 0;
+	}
 
-/**
+	/**
 	 * Determine if the maximum number of songs has been reached.
 	 */
-static inline bool
-queue_is_full(const struct queue *queue)
-{
-	assert(queue->length <= queue->max_length);
+	bool IsFull() const {
+		assert(length <= max_length);
 
-	return queue->length >= queue->max_length;
-}
+		return length >= max_length;
+	}
 
-/**
+	/**
 	 * Is that a valid position number?
 	 */
-static inline bool
-queue_valid_position(const struct queue *queue, unsigned position)
-{
-	return position < queue->length;
-}
+	bool IsValidPosition(unsigned position) const {
+		return position < length;
+	}
 
-/**
+	/**
 	 * Is that a valid order number?
 	 */
-static inline bool
-queue_valid_order(const struct queue *queue, unsigned order)
-{
-	return order < queue->length;
-}
-
-static inline int
-queue_id_to_position(const struct queue *queue, unsigned id)
-{
-	if (id >= queue->max_length * QUEUE_HASH_MULT)
+	bool IsValidOrder(unsigned _order) const {
+		return _order < length;
+	}
+
+	int IdToPosition(unsigned id) const {
+		if (id >= max_length * QUEUE_HASH_MULT)
 			return -1;
 
-	assert(queue->id_to_position[id] >= -1);
-	assert(queue->id_to_position[id] < (int)queue->length);
+		assert(id_to_position[id] >= -1);
+		assert(id_to_position[id] < (int)length);
 
-	return queue->id_to_position[id];
-}
+		return id_to_position[id];
+	}
 
-static inline int
-queue_position_to_id(const struct queue *queue, unsigned position)
-{
-	assert(position < queue->length);
+	int PositionToId(unsigned position) const
+	{
+		assert(position < length);
 
-	return queue->items[position].id;
-}
+		return items[position].id;
+	}
 
-static inline unsigned
-queue_order_to_position(const struct queue *queue, unsigned order)
-{
-	assert(order < queue->length);
+	gcc_pure
+	unsigned OrderToPosition(unsigned _order) const {
+		assert(_order < length);
 
-	return queue->order[order];
-}
+		return order[_order];
+	}
 
-static inline unsigned
-queue_position_to_order(const struct queue *queue, unsigned position)
-{
-	assert(position < queue->length);
+	gcc_pure
+	unsigned PositionToOrder(unsigned position) const {
+		assert(position < length);
 
 		for (unsigned i = 0;; ++i) {
-		assert(i < queue->length);
+			assert(i < length);
 
-		if (queue->order[i] == position)
+			if (order[i] == position)
 				return i;
 		}
-}
+	}
 
-G_GNUC_PURE
-static inline uint8_t
-queue_get_priority_at_position(const struct queue *queue, unsigned position)
-{
-	assert(position < queue->length);
+	G_GNUC_PURE
+	uint8_t GetPriorityAtPosition(unsigned position) const {
+		assert(position < length);
 
-	return queue->items[position].priority;
-}
+		return items[position].priority;
+	}
 
-/**
+	/**
 	 * Returns the song at the specified position.
 	 */
-static inline struct song *
-queue_get(const struct queue *queue, unsigned position)
-{
-	assert(position < queue->length);
+	struct song *Get(unsigned position) const {
+		assert(position < length);
 
-	return queue->items[position].song;
-}
+		return items[position].song;
+	}
 
-/**
+	/**
 	 * Returns the song at the specified order number.
 	 */
-static inline struct song *
-queue_get_order(const struct queue *queue, unsigned order)
-{
-	return queue_get(queue, queue_order_to_position(queue, order));
-}
+	struct song *GetOrder(unsigned _order) const {
+		return Get(OrderToPosition(_order));
+	}
 
-/**
+	/**
 	 * Is the song at the specified position newer than the specified
 	 * version?
 	 */
-static inline bool
-queue_song_newer(const struct queue *queue, unsigned position,
-		 uint32_t version)
-{
-	assert(position < queue->length);
+	bool IsNewerAtPosition(unsigned position, uint32_t _version) const {
+		assert(position < length);
 
-	return version > queue->version ||
-		queue->items[position].version >= version ||
-		queue->items[position].version == 0;
-}
+		return _version > version ||
+			items[position].version >= _version ||
+			items[position].version == 0;
+	}
 
-/**
+	/**
 	 * Returns the order number following the specified one.  This takes
 	 * end of queue and "repeat" mode into account.
 	 *
 	 * @return the next order number, or -1 to stop playback
 	 */
-int
-queue_next_order(const struct queue *queue, unsigned order);
+	gcc_pure
+	int GetNextOrder(unsigned order) const;
 
-/**
+	/**
 	 * Increments the queue's version number.  This handles integer
 	 * overflow well.
 	 */
-void
-queue_increment_version(struct queue *queue);
+	void IncrementVersion();
 
-/**
+	/**
 	 * Marks the specified song as "modified" and increments the version
 	 * number.
 	 */
-void
-queue_modify(struct queue *queue, unsigned order);
+	void ModifyAtOrder(unsigned order);
 
-/**
+	/**
 	 * Marks all songs as "modified" and increments the version number.
 	 */
-void
-queue_modify_all(struct queue *queue);
+	void ModifyAll();
 
-/**
+	/**
 	 * Appends a song to the queue and returns its position.  Prior to
 	 * that, the caller must check if the queue is already full.
 	 *
@@ -281,97 +254,79 @@ queue_modify_all(struct queue *queue);
 	 *
 	 * @param priority the priority of this new queue item
 	 */
-unsigned
-queue_append(struct queue *queue, struct song *song, uint8_t priority);
+	unsigned Append(struct song *song, uint8_t priority);
 
-/**
+	/**
 	 * Swaps two songs, addressed by their position.
 	 */
-void
-queue_swap(struct queue *queue, unsigned position1, unsigned position2);
+	void SwapPositions(unsigned position1, unsigned position2);
 
-/**
+	/**
 	 * Swaps two songs, addressed by their order number.
 	 */
-static inline void
-queue_swap_order(struct queue *queue, unsigned order1, unsigned order2)
-{
-	unsigned tmp = queue->order[order1];
-	queue->order[order1] = queue->order[order2];
-	queue->order[order2] = tmp;
-}
+	void SwapOrders(unsigned order1, unsigned order2) {
+		unsigned tmp = order[order1];
+		order[order1] = order[order2];
+		order[order2] = tmp;
+	}
 
-/**
+	/**
 	 * Moves a song to a new position.
 	 */
-void
-queue_move(struct queue *queue, unsigned from, unsigned to);
+	void MovePostion(unsigned from, unsigned to);
 
-/**
+	/**
 	 * Moves a range of songs to a new position.
 	 */
-void
-queue_move_range(struct queue *queue, unsigned start, unsigned end, unsigned to);
+	void MoveRange(unsigned start, unsigned end, unsigned to);
 
-/**
+	/**
 	 * Removes a song from the playlist.
 	 */
-void
-queue_delete(struct queue *queue, unsigned position);
+	void DeletePosition(unsigned position);
 
-/**
+	/**
 	 * Removes all songs from the playlist.
 	 */
-void
-queue_clear(struct queue *queue);
+	void Clear();
 
-/**
+	/**
 	 * Initializes the "order" array, and restores "normal" order.
 	 */
-static inline void
-queue_restore_order(struct queue *queue)
-{
-	for (unsigned i = 0; i < queue->length; ++i)
-		queue->order[i] = i;
-}
+	void RestoreOrder() {
+		for (unsigned i = 0; i < length; ++i)
+			order[i] = i;
+	}
 
-/**
+	/**
 	 * Shuffle the order of items in the specified range, taking their
 	 * priorities into account.
 	 */
-void
-queue_shuffle_order_range_with_priority(struct queue *queue,
-					unsigned start, unsigned end);
+	void ShuffleOrderRangeWithPriority(unsigned start, unsigned end);
 
-/**
+	/**
 	 * Shuffles the virtual order of songs, but does not move them
 	 * physically.  This is used in random mode.
 	 */
-void
-queue_shuffle_order(struct queue *queue);
+	void ShuffleOrder();
 
-/**
+	/**
 	 * Shuffles the virtual order of the last song in the specified
 	 * (order) range.  This is used in random mode after a song has been
 	 * appended by queue_append().
 	 */
-void
-queue_shuffle_order_last(struct queue *queue, unsigned start, unsigned end);
+	void ShuffleOrderLast(unsigned start, unsigned end);
 
-/**
+	/**
 	 * Shuffles a (position) range in the queue.  The songs are physically
 	 * shuffled, not by using the "order" mapping.
 	 */
-void
-queue_shuffle_range(struct queue *queue, unsigned start, unsigned end);
+	void ShuffleRange(unsigned start, unsigned end);
 
-bool
-queue_set_priority(struct queue *queue, unsigned position,
-		   uint8_t priority, int after_order);
+	bool SetPriority(unsigned position, uint8_t priority, int after_order);
 
-bool
-queue_set_priority_range(struct queue *queue,
-			 unsigned start_position, unsigned end_position,
+	bool SetPriorityRange(unsigned start_position, unsigned end_position,
 			      uint8_t priority, int after_order);
+};
 
 #endif

src/QueueCommands.cxx

@@ -171,7 +171,7 @@ enum command_return
 handle_shuffle(G_GNUC_UNUSED Client *client,
 	       G_GNUC_UNUSED int argc, G_GNUC_UNUSED char *argv[])
 {
-	unsigned start = 0, end = queue_length(&client->playlist.queue);
+	unsigned start = 0, end = client->playlist.queue.GetLength();
 	if (argc == 2 && !check_range(client, &start, &end, argv[1]))
 		return COMMAND_RETURN_ERROR;
 

src/QueuePrint.cxx

@@ -41,11 +41,11 @@ static void
 queue_print_song_info(Client *client, const struct queue *queue,
 		      unsigned position)
 {
-	song_print_info(client, queue_get(queue, position));
+	song_print_info(client, queue->Get(position));
 	client_printf(client, "Pos: %u\nId: %u\n",
-		      position, queue_position_to_id(queue, position));
+		      position, queue->PositionToId(position));
 
-	uint8_t priority = queue_get_priority_at_position(queue, position);
+	uint8_t priority = queue->GetPriorityAtPosition(position);
 	if (priority != 0)
 		client_printf(client, "Prio: %u\n", priority);
 }
@@ -55,7 +55,7 @@ queue_print_info(Client *client, const struct queue *queue,
 		 unsigned start, unsigned end)
 {
 	assert(start <= end);
-	assert(end <= queue_length(queue));
+	assert(end <= queue->GetLength());
 
 	for (unsigned i = start; i < end; ++i)
 		queue_print_song_info(client, queue, i);
@@ -66,11 +66,11 @@ queue_print_uris(Client *client, const struct queue *queue,
 		 unsigned start, unsigned end)
 {
 	assert(start <= end);
-	assert(end <= queue_length(queue));
+	assert(end <= queue->GetLength());
 
 	for (unsigned i = start; i < end; ++i) {
 		client_printf(client, "%i:", i);
-		song_print_uri(client, queue_get(queue, i));
+		song_print_uri(client, queue->Get(i));
 	}
 }
 
@@ -78,8 +78,8 @@ void
 queue_print_changes_info(Client *client, const struct queue *queue,
 			 uint32_t version)
 {
-	for (unsigned i = 0; i < queue_length(queue); i++) {
-		if (queue_song_newer(queue, i, version))
+	for (unsigned i = 0; i < queue->GetLength(); i++) {
+		if (queue->IsNewerAtPosition(i, version))
 			queue_print_song_info(client, queue, i);
 	}
 }
@@ -88,18 +88,18 @@ void
 queue_print_changes_position(Client *client, const struct queue *queue,
 			     uint32_t version)
 {
-	for (unsigned i = 0; i < queue_length(queue); i++)
-		if (queue_song_newer(queue, i, version))
+	for (unsigned i = 0; i < queue->GetLength(); i++)
+		if (queue->IsNewerAtPosition(i, version))
 			client_printf(client, "cpos: %i\nId: %i\n",
-				      i, queue_position_to_id(queue, i));
+				      i, queue->PositionToId(i));
 }
 
 void
 queue_find(Client *client, const struct queue *queue,
 	   const SongFilter &filter)
 {
-	for (unsigned i = 0; i < queue_length(queue); i++) {
-		const struct song *song = queue_get(queue, i);
+	for (unsigned i = 0; i < queue->GetLength(); i++) {
+		const struct song *song = queue->Get(i);
 
 		if (filter.Match(*song))
 			queue_print_song_info(client, queue, i);

src/QueueSave.cxx

@@ -61,19 +61,19 @@ queue_save_song(FILE *fp, int idx, const struct song *song)
 void
 queue_save(FILE *fp, const struct queue *queue)
 {
-	for (unsigned i = 0; i < queue_length(queue); i++) {
-		uint8_t prio = queue_get_priority_at_position(queue, i);
+	for (unsigned i = 0; i < queue->GetLength(); i++) {
+		uint8_t prio = queue->GetPriorityAtPosition(i);
 		if (prio != 0)
 			fprintf(fp, PRIO_LABEL "%u\n", prio);
 
-		queue_save_song(fp, i, queue_get(queue, i));
+		queue_save_song(fp, i, queue->Get(i));
 	}
 }
 
 void
 queue_load_song(TextFile &file, const char *line, queue *queue)
 {
-	if (queue_is_full(queue))
+	if (queue->IsFull())
 		return;
 
 	uint8_t priority = 0;
@@ -123,7 +123,7 @@ queue_load_song(TextFile &file, const char *line, queue *queue)
 		}
 	}
 
-	queue_append(queue, song, priority);
+	queue->Append(song, priority);
 
 	if (db != nullptr)
 		db->ReturnSong(song);

test/TestQueuePriority.cxx

@@ -23,21 +23,21 @@ G_GNUC_UNUSED
 static void
 dump_order(const struct queue *queue)
 {
-	g_printerr("queue length=%u, order:\n", queue_length(queue));
-	for (unsigned i = 0; i < queue_length(queue); ++i)
+	g_printerr("queue length=%u, order:\n", queue->GetLength());
+	for (unsigned i = 0; i < queue->GetLength(); ++i)
 		g_printerr("  [%u] -> %u (prio=%u)\n", i, queue->order[i],
 			   queue->items[queue->order[i]].priority);
 }
 
 static void
-check_descending_priority(G_GNUC_UNUSED const struct queue *queue,
+check_descending_priority(const struct queue *queue,
 			 unsigned start_order)
 {
-	assert(start_order < queue_length(queue));
+	assert(start_order < queue->GetLength());
 
 	uint8_t last_priority = 0xff;
-	for (unsigned order = start_order; order < queue_length(queue); ++order) {
-		unsigned position = queue_order_to_position(queue, order);
+	for (unsigned order = start_order; order < queue->GetLength(); ++order) {
+		unsigned position = queue->OrderToPosition(order);
 		uint8_t priority = queue->items[position].priority;
 		assert(priority <= last_priority);
 		(void)last_priority;
@@ -48,74 +48,74 @@ check_descending_priority(G_GNUC_UNUSED const struct queue *queue,
 int
 main(G_GNUC_UNUSED int argc, G_GNUC_UNUSED char **argv)
 {
-	struct song songs[16];
+	static struct song songs[16];
 
 	struct queue queue(32);
 
 	for (unsigned i = 0; i < G_N_ELEMENTS(songs); ++i)
-		queue_append(&queue, &songs[i], 0);
+		queue.Append(&songs[i], 0);
 
-	assert(queue_length(&queue) == G_N_ELEMENTS(songs));
+	assert(queue.GetLength() == G_N_ELEMENTS(songs));
 
 	/* priority=10 for 4 items */
 
-	queue_set_priority_range(&queue, 4, 8, 10, -1);
+	queue.SetPriorityRange(4, 8, 10, -1);
 
 	queue.random = true;
-	queue_shuffle_order(&queue);
+	queue.ShuffleOrder();
 	check_descending_priority(&queue, 0);
 
 	for (unsigned i = 0; i < 4; ++i) {
-		assert(queue_position_to_order(&queue, i) >= 4);
+		assert(queue.PositionToOrder(i) >= 4);
 	}
 
 	for (unsigned i = 4; i < 8; ++i) {
-		assert(queue_position_to_order(&queue, i) < 4);
+		assert(queue.PositionToOrder(i) < 4);
 	}
 
 	for (unsigned i = 8; i < G_N_ELEMENTS(songs); ++i) {
-		assert(queue_position_to_order(&queue, i) >= 4);
+		assert(queue.PositionToOrder(i) >= 4);
 	}
 
 	/* priority=50 one more item */
 
-	queue_set_priority_range(&queue, 15, 16, 50, -1);
+	queue.SetPriorityRange(15, 16, 50, -1);
 	check_descending_priority(&queue, 0);
 
-	assert(queue_position_to_order(&queue, 15) == 0);
+	assert(queue.PositionToOrder(15) == 0);
 
 	for (unsigned i = 0; i < 4; ++i) {
-		assert(queue_position_to_order(&queue, i) >= 4);
+		assert(queue.PositionToOrder(i) >= 4);
 	}
 
 	for (unsigned i = 4; i < 8; ++i) {
-		assert(queue_position_to_order(&queue, i) >= 1 &&
-		       queue_position_to_order(&queue, i) < 5);
+		assert(queue.PositionToOrder(i) >= 1 &&
+		       queue.PositionToOrder(i) < 5);
 	}
 
 	for (unsigned i = 8; i < 15; ++i) {
-		assert(queue_position_to_order(&queue, i) >= 5);
+		assert(queue.PositionToOrder(i) >= 5);
 	}
 
 	/* priority=20 for one of the 4 priority=10 items */
 
-	queue_set_priority_range(&queue, 3, 4, 20, -1);
+	queue.SetPriorityRange(3, 4, 20, -1);
 	check_descending_priority(&queue, 0);
 
-	assert(queue_position_to_order(&queue, 3) == 1);
-	assert(queue_position_to_order(&queue, 15) == 0);
+	assert(queue.PositionToOrder(3) == 1);
+	assert(queue.PositionToOrder(15) == 0);
 
 	for (unsigned i = 0; i < 3; ++i) {
-		assert(queue_position_to_order(&queue, i) >= 5);
+		assert(queue.PositionToOrder(i) >= 5);
 	}
 
 	for (unsigned i = 4; i < 8; ++i) {
-		assert(queue_position_to_order(&queue, i) >= 2 &&
-		       queue_position_to_order(&queue, i) < 6);
+		assert(queue.PositionToOrder(i) >= 2 &&
+		       queue.PositionToOrder(i) < 6);
 	}
 
 	for (unsigned i = 8; i < 15; ++i) {
-		assert(queue_position_to_order(&queue, i) >= 6);
+		assert(queue.PositionToOrder(i) >= 6);
 	}
 
 	/* priority=20 for another one of the 4 priority=10 items;
@@ -124,17 +124,17 @@ main(G_GNUC_UNUSED int argc, G_GNUC_UNUSED char **argv)
 
 	unsigned current_order = 4;
 	unsigned current_position =
-		queue_order_to_position(&queue, current_order);
+		queue.OrderToPosition(current_order);
 
 	unsigned a_order = 3;
-	unsigned a_position = queue_order_to_position(&queue, a_order);
+	unsigned a_position = queue.OrderToPosition(a_order);
 	assert(queue.items[a_position].priority == 10);
-	queue_set_priority(&queue, a_position, 20, current_order);
+	queue.SetPriority(a_position, 20, current_order);
 
-	current_order = queue_position_to_order(&queue, current_position);
+	current_order = queue.PositionToOrder(current_position);
 	assert(current_order == 3);
 
-	a_order = queue_position_to_order(&queue, a_position);
+	a_order = queue.PositionToOrder(a_position);
 	assert(a_order == 4);
 
 	check_descending_priority(&queue, current_order + 1);
@@ -144,14 +144,14 @@ main(G_GNUC_UNUSED int argc, G_GNUC_UNUSED char **argv)
 	   just created */
 
 	unsigned b_order = 10;
-	unsigned b_position = queue_order_to_position(&queue, b_order);
+	unsigned b_position = queue.OrderToPosition(b_order);
 	assert(queue.items[b_position].priority == 0);
-	queue_set_priority(&queue, b_position, 70, current_order);
+	queue.SetPriority(b_position, 70, current_order);
 
-	current_order = queue_position_to_order(&queue, current_position);
+	current_order = queue.PositionToOrder(current_position);
 	assert(current_order == 3);
 
-	b_order = queue_position_to_order(&queue, b_position);
+	b_order = queue.PositionToOrder(b_position);
 	assert(b_order == 4);
 
 	check_descending_priority(&queue, current_order + 1);
@@ -161,27 +161,26 @@ main(G_GNUC_UNUSED int argc, G_GNUC_UNUSED char **argv)
 	   hasn't changed (it was already higher before) */
 
 	unsigned c_order = 0;
-	unsigned c_position = queue_order_to_position(&queue, c_order);
+	unsigned c_position = queue.OrderToPosition(c_order);
 	assert(queue.items[c_position].priority == 50);
-	queue_set_priority(&queue, c_position, 60, current_order);
+	queue.SetPriority(c_position, 60, current_order);
 
-	current_order = queue_position_to_order(&queue, current_position);
+	current_order = queue.PositionToOrder(current_position);
 	assert(current_order == 3);
 
-	c_order = queue_position_to_order(&queue, c_position);
+	c_order = queue.PositionToOrder(c_position);
 	assert(c_order == 0);
 
 	/* move the prio=20 item back */
 
-	a_order = queue_position_to_order(&queue, a_position);
+	a_order = queue.PositionToOrder(a_position);
 	assert(a_order == 5);
 	assert(queue.items[a_position].priority == 20);
-	queue_set_priority(&queue, a_position, 5, current_order);
+	queue.SetPriority(a_position, 5, current_order);
 
-
-	current_order = queue_position_to_order(&queue, current_position);
+	current_order = queue.PositionToOrder(current_position);
 	assert(current_order == 3);
 
-	a_order = queue_position_to_order(&queue, a_position);
+	a_order = queue.PositionToOrder(a_position);
 	assert(a_order == 6);
 }