queue: convert all functions to methods
This commit is contained in:
Max Kellermann
644
src/Queue.cxx
644
src/Queue.cxx
@@ -23,283 +23,6 @@
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
/**
|
||||
* Generate a non-existing id number.
|
||||
*/
|
||||
static unsigned
|
||||
queue_generate_id(const struct queue *queue)
|
||||
{
|
||||
static unsigned cur = (unsigned)-1;
|
||||
|
||||
do {
|
||||
cur++;
|
||||
|
||||
if (cur >= queue->max_length * QUEUE_HASH_MULT)
|
||||
cur = 0;
|
||||
} while (queue->id_to_position[cur] != -1);
|
||||
|
||||
return cur;
|
||||
}
|
||||
|
||||
int
|
||||
queue_next_order(const struct queue *queue, unsigned order)
|
||||
{
|
||||
assert(order < queue->length);
|
||||
|
||||
if (queue->single && queue->repeat && !queue->consume)
|
||||
return order;
|
||||
else if (order + 1 < queue->length)
|
||||
return order + 1;
|
||||
else if (queue->repeat && (order > 0 || !queue->consume))
|
||||
/* restart at first song */
|
||||
return 0;
|
||||
else
|
||||
/* end of queue */
|
||||
return -1;
|
||||
}
|
||||
|
||||
void
|
||||
queue_increment_version(struct queue *queue)
|
||||
{
|
||||
static unsigned long max = ((uint32_t) 1 << 31) - 1;
|
||||
|
||||
queue->version++;
|
||||
|
||||
if (queue->version >= max) {
|
||||
for (unsigned i = 0; i < queue->length; i++)
|
||||
queue->items[i].version = 0;
|
||||
|
||||
queue->version = 1;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
queue_modify(struct queue *queue, unsigned order)
|
||||
{
|
||||
unsigned position;
|
||||
|
||||
assert(order < queue->length);
|
||||
|
||||
position = queue->order[order];
|
||||
queue->items[position].version = queue->version;
|
||||
|
||||
queue_increment_version(queue);
|
||||
}
|
||||
|
||||
void
|
||||
queue_modify_all(struct queue *queue)
|
||||
{
|
||||
for (unsigned i = 0; i < queue->length; i++)
|
||||
queue->items[i].version = queue->version;
|
||||
|
||||
queue_increment_version(queue);
|
||||
}
|
||||
|
||||
unsigned
|
||||
queue_append(struct queue *queue, struct song *song, uint8_t priority)
|
||||
{
|
||||
unsigned id = queue_generate_id(queue);
|
||||
|
||||
assert(!queue_is_full(queue));
|
||||
|
||||
auto &item = queue->items[queue->length];
|
||||
item.song = song_dup_detached(song);
|
||||
item.id = id;
|
||||
item.version = queue->version;
|
||||
item.priority = priority;
|
||||
|
||||
queue->order[queue->length] = queue->length;
|
||||
queue->id_to_position[id] = queue->length;
|
||||
|
||||
++queue->length;
|
||||
|
||||
return id;
|
||||
}
|
||||
|
||||
void
|
||||
queue_swap(struct queue *queue, unsigned position1, unsigned position2)
|
||||
{
|
||||
struct queue_item tmp;
|
||||
unsigned id1 = queue->items[position1].id;
|
||||
unsigned id2 = queue->items[position2].id;
|
||||
|
||||
tmp = queue->items[position1];
|
||||
queue->items[position1] = queue->items[position2];
|
||||
queue->items[position2] = tmp;
|
||||
|
||||
queue->items[position1].version = queue->version;
|
||||
queue->items[position2].version = queue->version;
|
||||
|
||||
queue->id_to_position[id1] = position2;
|
||||
queue->id_to_position[id2] = position1;
|
||||
}
|
||||
|
||||
static void
|
||||
queue_move_song_to(struct queue *queue, unsigned from, unsigned to)
|
||||
{
|
||||
unsigned from_id = queue->items[from].id;
|
||||
|
||||
queue->items[to] = queue->items[from];
|
||||
queue->items[to].version = queue->version;
|
||||
queue->id_to_position[from_id] = to;
|
||||
}
|
||||
|
||||
void
|
||||
queue_move(struct queue *queue, unsigned from, unsigned to)
|
||||
{
|
||||
struct queue_item item = queue->items[from];
|
||||
|
||||
/* move songs to one less in from->to */
|
||||
|
||||
for (unsigned i = from; i < to; i++)
|
||||
queue_move_song_to(queue, i + 1, i);
|
||||
|
||||
/* move songs to one more in to->from */
|
||||
|
||||
for (unsigned i = from; i > to; i--)
|
||||
queue_move_song_to(queue, i - 1, i);
|
||||
|
||||
/* put song at _to_ */
|
||||
|
||||
queue->id_to_position[item.id] = to;
|
||||
queue->items[to] = item;
|
||||
queue->items[to].version = queue->version;
|
||||
|
||||
/* now deal with order */
|
||||
|
||||
if (queue->random) {
|
||||
for (unsigned i = 0; i < queue->length; i++) {
|
||||
if (queue->order[i] > from && queue->order[i] <= to)
|
||||
queue->order[i]--;
|
||||
else if (queue->order[i] < from &&
|
||||
queue->order[i] >= to)
|
||||
queue->order[i]++;
|
||||
else if (from == queue->order[i])
|
||||
queue->order[i] = to;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
queue_move_range(struct queue *queue, unsigned start, unsigned end, unsigned to)
|
||||
{
|
||||
struct queue_item items[end - start];
|
||||
// Copy the original block [start,end-1]
|
||||
for (unsigned i = start; i < end; i++)
|
||||
items[i - start] = queue->items[i];
|
||||
|
||||
// If to > start, we need to move to-start items to start, starting from end
|
||||
for (unsigned i = end; i < end + to - start; i++)
|
||||
queue_move_song_to(queue, i, start + i - end);
|
||||
|
||||
// If to < start, we need to move start-to items to newend (= end + to - start), starting from to
|
||||
// This is the same as moving items from start-1 to to (decreasing), with start-1 going to end-1
|
||||
// We have to iterate in this order to avoid writing over something we haven't yet moved
|
||||
for (unsigned i = start - 1; i >= to && i != G_MAXUINT; i--)
|
||||
queue_move_song_to(queue, i, i + end - start);
|
||||
|
||||
// Copy the original block back in, starting at to.
|
||||
for (unsigned i = start; i< end; i++)
|
||||
{
|
||||
queue->id_to_position[items[i-start].id] = to + i - start;
|
||||
queue->items[to + i - start] = items[i-start];
|
||||
queue->items[to + i - start].version = queue->version;
|
||||
}
|
||||
|
||||
if (queue->random) {
|
||||
// Update the positions in the queue.
|
||||
// Note that the ranges for these cases are the same as the ranges of
|
||||
// the loops above.
|
||||
for (unsigned i = 0; i < queue->length; i++) {
|
||||
if (queue->order[i] >= end && queue->order[i] < to + end - start)
|
||||
queue->order[i] -= end - start;
|
||||
else if (queue->order[i] < start &&
|
||||
queue->order[i] >= to)
|
||||
queue->order[i] += end - start;
|
||||
else if (start <= queue->order[i] && queue->order[i] < end)
|
||||
queue->order[i] += to - start;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Moves a song to a new position in the "order" list.
|
||||
*/
|
||||
static void
|
||||
queue_move_order(struct queue *queue, unsigned from_order, unsigned to_order)
|
||||
{
|
||||
assert(queue != NULL);
|
||||
assert(from_order < queue->length);
|
||||
assert(to_order <= queue->length);
|
||||
|
||||
const unsigned from_position =
|
||||
queue_order_to_position(queue, from_order);
|
||||
|
||||
if (from_order < to_order) {
|
||||
for (unsigned i = from_order; i < to_order; ++i)
|
||||
queue->order[i] = queue->order[i + 1];
|
||||
} else {
|
||||
for (unsigned i = from_order; i > to_order; --i)
|
||||
queue->order[i] = queue->order[i - 1];
|
||||
}
|
||||
|
||||
queue->order[to_order] = from_position;
|
||||
}
|
||||
|
||||
void
|
||||
queue_delete(struct queue *queue, unsigned position)
|
||||
{
|
||||
struct song *song;
|
||||
unsigned id, order;
|
||||
|
||||
assert(position < queue->length);
|
||||
|
||||
song = queue_get(queue, position);
|
||||
assert(!song_in_database(song) || song_is_detached(song));
|
||||
song_free(song);
|
||||
|
||||
id = queue_position_to_id(queue, position);
|
||||
order = queue_position_to_order(queue, position);
|
||||
|
||||
--queue->length;
|
||||
|
||||
/* release the song id */
|
||||
|
||||
queue->id_to_position[id] = -1;
|
||||
|
||||
/* delete song from songs array */
|
||||
|
||||
for (unsigned i = position; i < queue->length; i++)
|
||||
queue_move_song_to(queue, i + 1, i);
|
||||
|
||||
/* delete the entry from the order array */
|
||||
|
||||
for (unsigned i = order; i < queue->length; i++)
|
||||
queue->order[i] = queue->order[i + 1];
|
||||
|
||||
/* readjust values in the order array */
|
||||
|
||||
for (unsigned i = 0; i < queue->length; i++)
|
||||
if (queue->order[i] > position)
|
||||
--queue->order[i];
|
||||
}
|
||||
|
||||
void
|
||||
queue_clear(struct queue *queue)
|
||||
{
|
||||
for (unsigned i = 0; i < queue->length; i++) {
|
||||
struct queue_item *item = &queue->items[i];
|
||||
|
||||
assert(!song_in_database(item->song) ||
|
||||
song_is_detached(item->song));
|
||||
song_free(item->song);
|
||||
|
||||
queue->id_to_position[item->id] = -1;
|
||||
}
|
||||
|
||||
queue->length = 0;
|
||||
}
|
||||
|
||||
queue::queue(unsigned _max_length)
|
||||
:max_length(_max_length), length(0),
|
||||
version(1),
|
||||
@@ -319,7 +42,7 @@ queue::queue(unsigned _max_length)
|
||||
|
||||
queue::~queue()
|
||||
{
|
||||
queue_clear(this);
|
||||
Clear();
|
||||
|
||||
g_free(items);
|
||||
g_free(order);
|
||||
@@ -328,6 +51,277 @@ queue::~queue()
|
||||
g_rand_free(rand);
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate a non-existing id number.
|
||||
*/
|
||||
static unsigned
|
||||
queue_generate_id(const struct queue *queue)
|
||||
{
|
||||
static unsigned cur = (unsigned)-1;
|
||||
|
||||
do {
|
||||
cur++;
|
||||
|
||||
if (cur >= queue->max_length * QUEUE_HASH_MULT)
|
||||
cur = 0;
|
||||
} while (queue->id_to_position[cur] != -1);
|
||||
|
||||
return cur;
|
||||
}
|
||||
|
||||
int
|
||||
queue::GetNextOrder(unsigned _order) const
|
||||
{
|
||||
assert(_order < length);
|
||||
|
||||
if (single && repeat && !consume)
|
||||
return _order;
|
||||
else if (_order + 1 < length)
|
||||
return _order + 1;
|
||||
else if (repeat && (_order > 0 || !consume))
|
||||
/* restart at first song */
|
||||
return 0;
|
||||
else
|
||||
/* end of queue */
|
||||
return -1;
|
||||
}
|
||||
|
||||
void
|
||||
queue::IncrementVersion()
|
||||
{
|
||||
static unsigned long max = ((uint32_t) 1 << 31) - 1;
|
||||
|
||||
version++;
|
||||
|
||||
if (version >= max) {
|
||||
for (unsigned i = 0; i < length; i++)
|
||||
items[i].version = 0;
|
||||
|
||||
version = 1;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
queue::ModifyAtOrder(unsigned _order)
|
||||
{
|
||||
assert(_order < length);
|
||||
|
||||
unsigned position = order[_order];
|
||||
items[position].version = version;
|
||||
|
||||
IncrementVersion();
|
||||
}
|
||||
|
||||
void
|
||||
queue::ModifyAll()
|
||||
{
|
||||
for (unsigned i = 0; i < length; i++)
|
||||
items[i].version = version;
|
||||
|
||||
IncrementVersion();
|
||||
}
|
||||
|
||||
unsigned
|
||||
queue::Append(struct song *song, uint8_t priority)
|
||||
{
|
||||
unsigned id = queue_generate_id(this);
|
||||
|
||||
assert(!IsFull());
|
||||
|
||||
auto &item = items[length];
|
||||
item.song = song_dup_detached(song);
|
||||
item.id = id;
|
||||
item.version = version;
|
||||
item.priority = priority;
|
||||
|
||||
order[length] = length;
|
||||
id_to_position[id] = length;
|
||||
|
||||
++length;
|
||||
|
||||
return id;
|
||||
}
|
||||
|
||||
void
|
||||
queue::SwapPositions(unsigned position1, unsigned position2)
|
||||
{
|
||||
struct queue_item tmp;
|
||||
unsigned id1 = items[position1].id;
|
||||
unsigned id2 = items[position2].id;
|
||||
|
||||
tmp = items[position1];
|
||||
items[position1] = items[position2];
|
||||
items[position2] = tmp;
|
||||
|
||||
items[position1].version = version;
|
||||
items[position2].version = version;
|
||||
|
||||
id_to_position[id1] = position2;
|
||||
id_to_position[id2] = position1;
|
||||
}
|
||||
|
||||
static void
|
||||
queue_move_song_to(struct queue *queue, unsigned from, unsigned to)
|
||||
{
|
||||
unsigned from_id = queue->items[from].id;
|
||||
|
||||
queue->items[to] = queue->items[from];
|
||||
queue->items[to].version = queue->version;
|
||||
queue->id_to_position[from_id] = to;
|
||||
}
|
||||
|
||||
void
|
||||
queue::MovePostion(unsigned from, unsigned to)
|
||||
{
|
||||
struct queue_item item = items[from];
|
||||
|
||||
/* move songs to one less in from->to */
|
||||
|
||||
for (unsigned i = from; i < to; i++)
|
||||
queue_move_song_to(this, i + 1, i);
|
||||
|
||||
/* move songs to one more in to->from */
|
||||
|
||||
for (unsigned i = from; i > to; i--)
|
||||
queue_move_song_to(this, i - 1, i);
|
||||
|
||||
/* put song at _to_ */
|
||||
|
||||
id_to_position[item.id] = to;
|
||||
items[to] = item;
|
||||
items[to].version = version;
|
||||
|
||||
/* now deal with order */
|
||||
|
||||
if (random) {
|
||||
for (unsigned i = 0; i < length; i++) {
|
||||
if (order[i] > from && order[i] <= to)
|
||||
order[i]--;
|
||||
else if (order[i] < from &&
|
||||
order[i] >= to)
|
||||
order[i]++;
|
||||
else if (from == order[i])
|
||||
order[i] = to;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
queue::MoveRange(unsigned start, unsigned end, unsigned to)
|
||||
{
|
||||
struct queue_item tmp[end - start];
|
||||
// Copy the original block [start,end-1]
|
||||
for (unsigned i = start; i < end; i++)
|
||||
tmp[i - start] = items[i];
|
||||
|
||||
// If to > start, we need to move to-start items to start, starting from end
|
||||
for (unsigned i = end; i < end + to - start; i++)
|
||||
queue_move_song_to(this, i, start + i - end);
|
||||
|
||||
// If to < start, we need to move start-to items to newend (= end + to - start), starting from to
|
||||
// This is the same as moving items from start-1 to to (decreasing), with start-1 going to end-1
|
||||
// We have to iterate in this order to avoid writing over something we haven't yet moved
|
||||
for (unsigned i = start - 1; i >= to && i != G_MAXUINT; i--)
|
||||
queue_move_song_to(this, i, i + end - start);
|
||||
|
||||
// Copy the original block back in, starting at to.
|
||||
for (unsigned i = start; i< end; i++)
|
||||
{
|
||||
id_to_position[tmp[i-start].id] = to + i - start;
|
||||
items[to + i - start] = tmp[i-start];
|
||||
items[to + i - start].version = version;
|
||||
}
|
||||
|
||||
if (random) {
|
||||
// Update the positions in the queue.
|
||||
// Note that the ranges for these cases are the same as the ranges of
|
||||
// the loops above.
|
||||
for (unsigned i = 0; i < length; i++) {
|
||||
if (order[i] >= end && order[i] < to + end - start)
|
||||
order[i] -= end - start;
|
||||
else if (order[i] < start &&
|
||||
order[i] >= to)
|
||||
order[i] += end - start;
|
||||
else if (start <= order[i] && order[i] < end)
|
||||
order[i] += to - start;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Moves a song to a new position in the "order" list.
|
||||
*/
|
||||
static void
|
||||
queue_move_order(struct queue *queue, unsigned from_order, unsigned to_order)
|
||||
{
|
||||
assert(queue != NULL);
|
||||
assert(from_order < queue->length);
|
||||
assert(to_order <= queue->length);
|
||||
|
||||
const unsigned from_position = queue->OrderToPosition(from_order);
|
||||
|
||||
if (from_order < to_order) {
|
||||
for (unsigned i = from_order; i < to_order; ++i)
|
||||
queue->order[i] = queue->order[i + 1];
|
||||
} else {
|
||||
for (unsigned i = from_order; i > to_order; --i)
|
||||
queue->order[i] = queue->order[i - 1];
|
||||
}
|
||||
|
||||
queue->order[to_order] = from_position;
|
||||
}
|
||||
|
||||
void
|
||||
queue::DeletePosition(unsigned position)
|
||||
{
|
||||
assert(position < length);
|
||||
|
||||
struct song *song = Get(position);
|
||||
assert(!song_in_database(song) || song_is_detached(song));
|
||||
song_free(song);
|
||||
|
||||
const unsigned id = PositionToId(position);
|
||||
const unsigned _order = PositionToOrder(position);
|
||||
|
||||
--length;
|
||||
|
||||
/* release the song id */
|
||||
|
||||
id_to_position[id] = -1;
|
||||
|
||||
/* delete song from songs array */
|
||||
|
||||
for (unsigned i = position; i < length; i++)
|
||||
queue_move_song_to(this, i + 1, i);
|
||||
|
||||
/* delete the entry from the order array */
|
||||
|
||||
for (unsigned i = _order; i < length; i++)
|
||||
order[i] = order[i + 1];
|
||||
|
||||
/* readjust values in the order array */
|
||||
|
||||
for (unsigned i = 0; i < length; i++)
|
||||
if (order[i] > position)
|
||||
--order[i];
|
||||
}
|
||||
|
||||
void
|
||||
queue::Clear()
|
||||
{
|
||||
for (unsigned i = 0; i < length; i++) {
|
||||
struct queue_item *item = &items[i];
|
||||
|
||||
assert(!song_in_database(item->song) ||
|
||||
song_is_detached(item->song));
|
||||
song_free(item->song);
|
||||
|
||||
id_to_position[item->id] = -1;
|
||||
}
|
||||
|
||||
length = 0;
|
||||
}
|
||||
|
||||
static const struct queue_item *
|
||||
queue_get_order_item_const(const struct queue *queue, unsigned order)
|
||||
{
|
||||
@@ -390,8 +384,7 @@ queue_shuffle_order_range(struct queue *queue, unsigned start, unsigned end)
|
||||
assert(end <= queue->length);
|
||||
|
||||
for (unsigned i = start; i < end; ++i)
|
||||
queue_swap_order(queue, i,
|
||||
g_rand_int_range(queue->rand, i, end));
|
||||
queue->SwapOrders(i, g_rand_int_range(queue->rand, i, end));
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -399,70 +392,66 @@ queue_shuffle_order_range(struct queue *queue, unsigned start, unsigned end)
|
||||
* priority group.
|
||||
*/
|
||||
void
|
||||
queue_shuffle_order_range_with_priority(struct queue *queue,
|
||||
unsigned start, unsigned end)
|
||||
queue::ShuffleOrderRangeWithPriority(unsigned start, unsigned end)
|
||||
{
|
||||
assert(queue != NULL);
|
||||
assert(queue->random);
|
||||
assert(random);
|
||||
assert(start <= end);
|
||||
assert(end <= queue->length);
|
||||
assert(end <= length);
|
||||
|
||||
if (start == end)
|
||||
return;
|
||||
|
||||
/* first group the range by priority */
|
||||
queue_sort_order_by_priority(queue, start, end);
|
||||
queue_sort_order_by_priority(this, start, end);
|
||||
|
||||
/* now shuffle each priority group */
|
||||
unsigned group_start = start;
|
||||
uint8_t group_priority = queue_get_order_priority(queue, start);
|
||||
uint8_t group_priority = queue_get_order_priority(this, start);
|
||||
|
||||
for (unsigned i = start + 1; i < end; ++i) {
|
||||
uint8_t priority = queue_get_order_priority(queue, i);
|
||||
uint8_t priority = queue_get_order_priority(this, i);
|
||||
assert(priority <= group_priority);
|
||||
|
||||
if (priority != group_priority) {
|
||||
/* start of a new group - shuffle the one that
|
||||
has just ended */
|
||||
queue_shuffle_order_range(queue, group_start, i);
|
||||
queue_shuffle_order_range(this, group_start, i);
|
||||
group_start = i;
|
||||
group_priority = priority;
|
||||
}
|
||||
}
|
||||
|
||||
/* shuffle the last group */
|
||||
queue_shuffle_order_range(queue, group_start, end);
|
||||
queue_shuffle_order_range(this, group_start, end);
|
||||
}
|
||||
|
||||
void
|
||||
queue_shuffle_order(struct queue *queue)
|
||||
queue::ShuffleOrder()
|
||||
{
|
||||
queue_shuffle_order_range_with_priority(queue, 0, queue->length);
|
||||
ShuffleOrderRangeWithPriority(0, length);
|
||||
}
|
||||
|
||||
static void
|
||||
queue_shuffle_order_first(struct queue *queue, unsigned start, unsigned end)
|
||||
{
|
||||
queue_swap_order(queue, start,
|
||||
g_rand_int_range(queue->rand, start, end));
|
||||
queue->SwapOrders(start, g_rand_int_range(queue->rand, start, end));
|
||||
}
|
||||
|
||||
void
|
||||
queue_shuffle_order_last(struct queue *queue, unsigned start, unsigned end)
|
||||
queue::ShuffleOrderLast(unsigned start, unsigned end)
|
||||
{
|
||||
queue_swap_order(queue, end - 1,
|
||||
g_rand_int_range(queue->rand, start, end));
|
||||
SwapOrders(end - 1, g_rand_int_range(rand, start, end));
|
||||
}
|
||||
|
||||
void
|
||||
queue_shuffle_range(struct queue *queue, unsigned start, unsigned end)
|
||||
queue::ShuffleRange(unsigned start, unsigned end)
|
||||
{
|
||||
assert(start <= end);
|
||||
assert(end <= queue->length);
|
||||
assert(end <= length);
|
||||
|
||||
for (unsigned i = start; i < end; i++) {
|
||||
unsigned ri = g_rand_int_range(queue->rand, i, end);
|
||||
queue_swap(queue, i, ri);
|
||||
unsigned ri = g_rand_int_range(rand, i, end);
|
||||
SwapPositions(i, ri);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -479,7 +468,7 @@ queue_find_priority_order(const struct queue *queue, unsigned start_order,
|
||||
assert(start_order <= queue->length);
|
||||
|
||||
for (unsigned order = start_order; order < queue->length; ++order) {
|
||||
const unsigned position = queue_order_to_position(queue, order);
|
||||
const unsigned position = queue->OrderToPosition(order);
|
||||
const struct queue_item *item = &queue->items[position];
|
||||
if (item->priority <= priority && order != exclude_order)
|
||||
return order;
|
||||
@@ -498,7 +487,7 @@ queue_count_same_priority(const struct queue *queue, unsigned start_order,
|
||||
assert(start_order <= queue->length);
|
||||
|
||||
for (unsigned order = start_order; order < queue->length; ++order) {
|
||||
const unsigned position = queue_order_to_position(queue, order);
|
||||
const unsigned position = queue->OrderToPosition(order);
|
||||
const struct queue_item *item = &queue->items[position];
|
||||
if (item->priority != priority)
|
||||
return order - start_order;
|
||||
@@ -508,39 +497,37 @@ queue_count_same_priority(const struct queue *queue, unsigned start_order,
|
||||
}
|
||||
|
||||
bool
|
||||
queue_set_priority(struct queue *queue, unsigned position, uint8_t priority,
|
||||
int after_order)
|
||||
queue::SetPriority(unsigned position, uint8_t priority, int after_order)
|
||||
{
|
||||
assert(queue != NULL);
|
||||
assert(position < queue->length);
|
||||
assert(position < length);
|
||||
|
||||
struct queue_item *item = &queue->items[position];
|
||||
struct queue_item *item = &items[position];
|
||||
uint8_t old_priority = item->priority;
|
||||
if (old_priority == priority)
|
||||
return false;
|
||||
|
||||
item->version = queue->version;
|
||||
item->version = version;
|
||||
item->priority = priority;
|
||||
|
||||
if (!queue->random)
|
||||
if (!random)
|
||||
/* don't reorder if not in random mode */
|
||||
return true;
|
||||
|
||||
unsigned order = queue_position_to_order(queue, position);
|
||||
unsigned _order = PositionToOrder(position);
|
||||
if (after_order >= 0) {
|
||||
if (order == (unsigned)after_order)
|
||||
if (_order == (unsigned)after_order)
|
||||
/* don't reorder the current song */
|
||||
return true;
|
||||
|
||||
if (order < (unsigned)after_order) {
|
||||
if (_order < (unsigned)after_order) {
|
||||
/* the specified song has been played already
|
||||
- enqueue it only if its priority has just
|
||||
become bigger than the current one's */
|
||||
|
||||
const unsigned after_position =
|
||||
queue_order_to_position(queue, after_order);
|
||||
OrderToPosition(after_order);
|
||||
const struct queue_item *after_item =
|
||||
&queue->items[after_position];
|
||||
&items[after_position];
|
||||
if (old_priority > after_item->priority ||
|
||||
priority <= after_item->priority)
|
||||
/* priority hasn't become bigger */
|
||||
@@ -552,44 +539,41 @@ queue_set_priority(struct queue *queue, unsigned position, uint8_t priority,
|
||||
create a new priority group) */
|
||||
|
||||
const unsigned before_order =
|
||||
queue_find_priority_order(queue, after_order + 1, priority,
|
||||
order);
|
||||
const unsigned new_order = before_order > order
|
||||
queue_find_priority_order(this, after_order + 1, priority,
|
||||
_order);
|
||||
const unsigned new_order = before_order > _order
|
||||
? before_order - 1
|
||||
: before_order;
|
||||
queue_move_order(queue, order, new_order);
|
||||
queue_move_order(this, _order, new_order);
|
||||
|
||||
/* shuffle the song within that priority group */
|
||||
|
||||
const unsigned priority_count =
|
||||
queue_count_same_priority(queue, new_order, priority);
|
||||
queue_count_same_priority(this, new_order, priority);
|
||||
assert(priority_count >= 1);
|
||||
queue_shuffle_order_first(queue, new_order,
|
||||
queue_shuffle_order_first(this, new_order,
|
||||
new_order + priority_count);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool
|
||||
queue_set_priority_range(struct queue *queue,
|
||||
unsigned start_position, unsigned end_position,
|
||||
uint8_t priority, int after_order)
|
||||
queue::SetPriorityRange(unsigned start_position, unsigned end_position,
|
||||
uint8_t priority, int after_order)
|
||||
{
|
||||
assert(queue != NULL);
|
||||
assert(start_position <= end_position);
|
||||
assert(end_position <= queue->length);
|
||||
assert(end_position <= length);
|
||||
|
||||
bool modified = false;
|
||||
int after_position = after_order >= 0
|
||||
? (int)queue_order_to_position(queue, after_order)
|
||||
? (int)OrderToPosition(after_order)
|
||||
: -1;
|
||||
for (unsigned i = start_position; i < end_position; ++i) {
|
||||
after_order = after_position >= 0
|
||||
? (int)queue_position_to_order(queue, after_position)
|
||||
? (int)PositionToOrder(after_position)
|
||||
: -1;
|
||||
|
||||
modified |= queue_set_priority(queue, i, priority,
|
||||
after_order);
|
||||
modified |= SetPriority(i, priority, after_order);
|
||||
}
|
||||
|
||||
return modified;
|
||||
|
||||
Reference in New Issue
Block a user