- No more IndexRecord/Result/dbGetPage nonsense - Queue is just track ids - i am so tired and have so much to docustom
jacqueline
1 year ago
parent
009f69c929
commit
3f7f199cb9
File diff suppressed because it is too large
Load Diff
@ -1,10 +0,0 @@ |
|||||||
# Copyright 2023 jacqueline <me@jacqueline.id.au> |
|
||||||
# |
|
||||||
# SPDX-License-Identifier: GPL-3.0-only |
|
||||||
|
|
||||||
idf_component_register( |
|
||||||
SRCS "source.cpp" "shuffler.cpp" |
|
||||||
INCLUDE_DIRS "include" |
|
||||||
REQUIRES "database" "util") |
|
||||||
|
|
||||||
target_compile_options(${COMPONENT_LIB} PRIVATE ${EXTRA_WARNINGS}) |
|
||||||
@ -1,68 +0,0 @@ |
|||||||
/*
|
|
||||||
* Copyright 2023 jacqueline <me@jacqueline.id.au> |
|
||||||
* |
|
||||||
* SPDX-License-Identifier: GPL-3.0-only |
|
||||||
*/ |
|
||||||
|
|
||||||
#pragma once |
|
||||||
|
|
||||||
#include <deque> |
|
||||||
#include <memory> |
|
||||||
#include <mutex> |
|
||||||
#include <variant> |
|
||||||
#include <vector> |
|
||||||
|
|
||||||
#include "bloom_filter.hpp" |
|
||||||
#include "database.hpp" |
|
||||||
#include "future_fetcher.hpp" |
|
||||||
#include "random.hpp" |
|
||||||
#include "source.hpp" |
|
||||||
#include "track.hpp" |
|
||||||
|
|
||||||
namespace playlist { |
|
||||||
|
|
||||||
/*
|
|
||||||
* A source composes of other sources and/or specific extra tracks. Supports |
|
||||||
* iteration over its contents in a random order. |
|
||||||
*/ |
|
||||||
class Shuffler : public ISource { |
|
||||||
public: |
|
||||||
static auto Create() -> Shuffler*; |
|
||||||
|
|
||||||
explicit Shuffler( |
|
||||||
util::IRandom* random, |
|
||||||
std::unique_ptr<util::BloomFilter<database::TrackId>> filter); |
|
||||||
|
|
||||||
auto Current() -> std::optional<database::TrackId> override; |
|
||||||
auto Advance() -> std::optional<database::TrackId> override; |
|
||||||
auto Peek(std::size_t, std::vector<database::TrackId>*) |
|
||||||
-> std::size_t override; |
|
||||||
|
|
||||||
typedef std::variant<database::TrackId, std::shared_ptr<IResetableSource>> |
|
||||||
Item; |
|
||||||
auto Add(Item) -> void; |
|
||||||
|
|
||||||
/*
|
|
||||||
* Returns the enqueued items, starting from the current item, in their |
|
||||||
* original insertion order. |
|
||||||
*/ |
|
||||||
auto Unshuffle() -> std::vector<Item>; |
|
||||||
|
|
||||||
// Not copyable or movable.
|
|
||||||
|
|
||||||
Shuffler(const Shuffler&) = delete; |
|
||||||
Shuffler& operator=(const Shuffler&) = delete; |
|
||||||
|
|
||||||
private: |
|
||||||
auto RefillBuffer() -> void; |
|
||||||
|
|
||||||
util::IRandom* random_; |
|
||||||
|
|
||||||
std::unique_ptr<util::BloomFilter<database::TrackId>> already_played_; |
|
||||||
bool out_of_items_; |
|
||||||
|
|
||||||
std::deque<Item> ordered_items_; |
|
||||||
std::deque<database::TrackId> shuffled_items_buffer_; |
|
||||||
}; |
|
||||||
|
|
||||||
} // namespace playlist
|
|
||||||
@ -1,157 +0,0 @@ |
|||||||
/*
|
|
||||||
* Copyright 2023 jacqueline <me@jacqueline.id.au> |
|
||||||
* |
|
||||||
* SPDX-License-Identifier: GPL-3.0-only |
|
||||||
*/ |
|
||||||
|
|
||||||
#pragma once |
|
||||||
|
|
||||||
#include <deque> |
|
||||||
#include <memory> |
|
||||||
#include <mutex> |
|
||||||
#include <stack> |
|
||||||
#include <variant> |
|
||||||
#include <vector> |
|
||||||
|
|
||||||
#include "bloom_filter.hpp" |
|
||||||
#include "database.hpp" |
|
||||||
#include "future_fetcher.hpp" |
|
||||||
#include "random.hpp" |
|
||||||
#include "track.hpp" |
|
||||||
|
|
||||||
namespace playlist { |
|
||||||
|
|
||||||
/*
|
|
||||||
* Stateful interface for iterating over a collection of tracks by id. |
|
||||||
*/ |
|
||||||
class ISource { |
|
||||||
public: |
|
||||||
virtual ~ISource() {} |
|
||||||
|
|
||||||
virtual auto Current() -> std::optional<database::TrackId> = 0; |
|
||||||
|
|
||||||
/*
|
|
||||||
* Discards the current track id and continues to the next in this source. |
|
||||||
* Returns the new current track id. |
|
||||||
*/ |
|
||||||
virtual auto Advance() -> std::optional<database::TrackId> = 0; |
|
||||||
|
|
||||||
/*
|
|
||||||
* Repeatedly advances until a track with the given id is the current track. |
|
||||||
* Returns false if this source ran out of tracks before the requested id |
|
||||||
* was encounted, true otherwise. |
|
||||||
*/ |
|
||||||
virtual auto AdvanceTo(database::TrackId id) -> bool { |
|
||||||
for (auto t = Current(); t.has_value(); t = Advance()) { |
|
||||||
if (*t == id) { |
|
||||||
return true; |
|
||||||
} |
|
||||||
} |
|
||||||
return false; |
|
||||||
} |
|
||||||
|
|
||||||
/*
|
|
||||||
* Places the next n tracks into the given vector, in order. Does not change |
|
||||||
* the value returned by Current(). |
|
||||||
*/ |
|
||||||
virtual auto Peek(std::size_t n, std::vector<database::TrackId>*) |
|
||||||
-> std::size_t = 0; |
|
||||||
}; |
|
||||||
|
|
||||||
/*
|
|
||||||
* A Source that supports restarting iteration from its original initial |
|
||||||
* value. |
|
||||||
*/ |
|
||||||
class IResetableSource : public ISource { |
|
||||||
public: |
|
||||||
virtual ~IResetableSource() {} |
|
||||||
|
|
||||||
virtual auto Previous() -> std::optional<database::TrackId> = 0; |
|
||||||
|
|
||||||
/*
|
|
||||||
* Restarts iteration from this source's initial value. |
|
||||||
*/ |
|
||||||
virtual auto Reset() -> void = 0; |
|
||||||
}; |
|
||||||
|
|
||||||
class IteratorSource : public IResetableSource { |
|
||||||
public: |
|
||||||
IteratorSource(const database::Iterator&); |
|
||||||
|
|
||||||
auto Current() -> std::optional<database::TrackId> override; |
|
||||||
auto Advance() -> std::optional<database::TrackId> override; |
|
||||||
auto Peek(std::size_t n, std::vector<database::TrackId>*) |
|
||||||
-> std::size_t override; |
|
||||||
|
|
||||||
auto Previous() -> std::optional<database::TrackId> override; |
|
||||||
auto Reset() -> void override; |
|
||||||
|
|
||||||
private: |
|
||||||
const database::Iterator& start_; |
|
||||||
std::optional<database::TrackId> current_; |
|
||||||
std::stack<database::Iterator, std::vector<database::Iterator>> next_; |
|
||||||
}; |
|
||||||
|
|
||||||
auto CreateSourceFromResults( |
|
||||||
std::weak_ptr<database::Database>, |
|
||||||
std::shared_ptr<database::Result<database::IndexRecord>>) |
|
||||||
-> std::shared_ptr<IResetableSource>; |
|
||||||
|
|
||||||
class IndexRecordSource : public IResetableSource { |
|
||||||
public: |
|
||||||
IndexRecordSource(std::weak_ptr<database::Database> db, |
|
||||||
std::shared_ptr<database::Result<database::IndexRecord>>); |
|
||||||
|
|
||||||
IndexRecordSource(std::weak_ptr<database::Database> db, |
|
||||||
std::shared_ptr<database::Result<database::IndexRecord>>, |
|
||||||
std::size_t, |
|
||||||
std::shared_ptr<database::Result<database::IndexRecord>>, |
|
||||||
std::size_t); |
|
||||||
|
|
||||||
auto Current() -> std::optional<database::TrackId> override; |
|
||||||
auto Advance() -> std::optional<database::TrackId> override; |
|
||||||
auto Peek(std::size_t n, std::vector<database::TrackId>*) |
|
||||||
-> std::size_t override; |
|
||||||
|
|
||||||
auto Previous() -> std::optional<database::TrackId> override; |
|
||||||
auto Reset() -> void override; |
|
||||||
|
|
||||||
private: |
|
||||||
std::weak_ptr<database::Database> db_; |
|
||||||
|
|
||||||
std::shared_ptr<database::Result<database::IndexRecord>> initial_page_; |
|
||||||
ssize_t initial_item_; |
|
||||||
|
|
||||||
std::shared_ptr<database::Result<database::IndexRecord>> current_page_; |
|
||||||
ssize_t current_item_; |
|
||||||
}; |
|
||||||
|
|
||||||
class NestedSource : public IResetableSource { |
|
||||||
public: |
|
||||||
NestedSource(std::weak_ptr<database::Database> db, |
|
||||||
std::shared_ptr<database::Result<database::IndexRecord>>); |
|
||||||
|
|
||||||
auto Current() -> std::optional<database::TrackId> override; |
|
||||||
auto Advance() -> std::optional<database::TrackId> override; |
|
||||||
auto Peek(std::size_t n, std::vector<database::TrackId>*) |
|
||||||
-> std::size_t override; |
|
||||||
|
|
||||||
auto Previous() -> std::optional<database::TrackId> override; |
|
||||||
auto Reset() -> void override; |
|
||||||
|
|
||||||
private: |
|
||||||
auto CreateChild(std::shared_ptr<database::IndexRecord> page) |
|
||||||
-> std::shared_ptr<IResetableSource>; |
|
||||||
|
|
||||||
std::weak_ptr<database::Database> db_; |
|
||||||
|
|
||||||
std::shared_ptr<database::Result<database::IndexRecord>> initial_page_; |
|
||||||
ssize_t initial_item_; |
|
||||||
|
|
||||||
std::shared_ptr<database::Result<database::IndexRecord>> current_page_; |
|
||||||
ssize_t current_item_; |
|
||||||
|
|
||||||
std::shared_ptr<IResetableSource> current_child_; |
|
||||||
}; |
|
||||||
|
|
||||||
} // namespace playlist
|
|
||||||
@ -1,166 +0,0 @@ |
|||||||
/*
|
|
||||||
* Copyright 2023 jacqueline <me@jacqueline.id.au> |
|
||||||
* |
|
||||||
* SPDX-License-Identifier: GPL-3.0-only |
|
||||||
*/ |
|
||||||
|
|
||||||
#include "shuffler.hpp" |
|
||||||
|
|
||||||
#include <algorithm> |
|
||||||
#include <functional> |
|
||||||
#include <memory> |
|
||||||
#include <set> |
|
||||||
#include <variant> |
|
||||||
|
|
||||||
#include "bloom_filter.hpp" |
|
||||||
#include "database.hpp" |
|
||||||
#include "komihash.h" |
|
||||||
#include "random.hpp" |
|
||||||
#include "track.hpp" |
|
||||||
|
|
||||||
static constexpr std::size_t kShufflerBufferSize = 32; |
|
||||||
|
|
||||||
namespace playlist { |
|
||||||
|
|
||||||
auto Shuffler::Create() -> Shuffler* { |
|
||||||
return new Shuffler(util::sRandom, |
|
||||||
std::make_unique<util::BloomFilter<database::TrackId>>( |
|
||||||
[](database::TrackId id) { |
|
||||||
return komihash(&id, sizeof(database::TrackId), 0); |
|
||||||
})); |
|
||||||
} |
|
||||||
|
|
||||||
Shuffler::Shuffler(util::IRandom* random, |
|
||||||
std::unique_ptr<util::BloomFilter<database::TrackId>> filter) |
|
||||||
: random_(random), already_played_(std::move(filter)) {} |
|
||||||
|
|
||||||
auto Shuffler::Current() -> std::optional<database::TrackId> { |
|
||||||
if (shuffled_items_buffer_.empty()) { |
|
||||||
return {}; |
|
||||||
} |
|
||||||
return shuffled_items_buffer_.front(); |
|
||||||
} |
|
||||||
|
|
||||||
auto Shuffler::Advance() -> std::optional<database::TrackId> { |
|
||||||
if (shuffled_items_buffer_.empty() && !out_of_items_) { |
|
||||||
RefillBuffer(); |
|
||||||
} |
|
||||||
|
|
||||||
auto res = Current(); |
|
||||||
if (res) { |
|
||||||
// Mark tracks off in the bloom filter only *after* they've been advanced
|
|
||||||
// past. This gives us the most flexibility for reshuffling when adding new
|
|
||||||
// items.
|
|
||||||
already_played_->Insert(*res); |
|
||||||
shuffled_items_buffer_.pop_front(); |
|
||||||
} |
|
||||||
return res; |
|
||||||
} |
|
||||||
|
|
||||||
auto Shuffler::Peek(std::size_t num, std::vector<database::TrackId>* out) |
|
||||||
-> std::size_t { |
|
||||||
if (shuffled_items_buffer_.size() < num) { |
|
||||||
RefillBuffer(); |
|
||||||
} |
|
||||||
for (int i = 0; i < num; i++) { |
|
||||||
if (i >= shuffled_items_buffer_.size()) { |
|
||||||
// We must be out of data, since the buffer didn't fill up.
|
|
||||||
return i; |
|
||||||
} |
|
||||||
out->push_back(shuffled_items_buffer_.at(i)); |
|
||||||
} |
|
||||||
return num; |
|
||||||
} |
|
||||||
|
|
||||||
auto Shuffler::Add(Item item) -> void { |
|
||||||
ordered_items_.push_back(item); |
|
||||||
out_of_items_ = false; |
|
||||||
|
|
||||||
// Empty out the buffer of already shuffled items, since we will need to
|
|
||||||
// shuffle again in order to incorporate the newly added item(s). We keep the
|
|
||||||
// current item however because we wouldn't want Add() to change the value of
|
|
||||||
// Current() unless we're completely out of items.
|
|
||||||
if (shuffled_items_buffer_.size() > 1) { |
|
||||||
shuffled_items_buffer_.erase(shuffled_items_buffer_.begin() + 1, |
|
||||||
shuffled_items_buffer_.end()); |
|
||||||
} |
|
||||||
RefillBuffer(); |
|
||||||
} |
|
||||||
|
|
||||||
auto Shuffler::Unshuffle() -> std::vector<Item> { |
|
||||||
std::vector<Item> ret; |
|
||||||
database::TrackId current = shuffled_items_buffer_.front(); |
|
||||||
bool has_found_current = false; |
|
||||||
|
|
||||||
for (const Item& item : ordered_items_) { |
|
||||||
if (!has_found_current) { |
|
||||||
// TODO(jacqueline): *Should* this include previous items? What is the
|
|
||||||
// 'previous' button meant to do after unshuffling?
|
|
||||||
if (std::holds_alternative<database::TrackId>(item)) { |
|
||||||
has_found_current = current == std::get<database::TrackId>(item); |
|
||||||
} else { |
|
||||||
auto source = std::get<std::shared_ptr<IResetableSource>>(item); |
|
||||||
source->Reset(); |
|
||||||
has_found_current = |
|
||||||
std::get<std::shared_ptr<IResetableSource>>(item)->AdvanceTo( |
|
||||||
current); |
|
||||||
} |
|
||||||
} else { |
|
||||||
ret.push_back(item); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
return ret; |
|
||||||
} |
|
||||||
|
|
||||||
auto Shuffler::RefillBuffer() -> void { |
|
||||||
// Don't waste time iterating if we know there's nothing new.
|
|
||||||
if (out_of_items_) { |
|
||||||
return; |
|
||||||
} |
|
||||||
|
|
||||||
int num_to_sample = kShufflerBufferSize - shuffled_items_buffer_.size(); |
|
||||||
int resovoir_offset = shuffled_items_buffer_.size(); |
|
||||||
|
|
||||||
std::set<database::TrackId> in_buffer; |
|
||||||
for (const database::TrackId& id : shuffled_items_buffer_) { |
|
||||||
in_buffer.insert(id); |
|
||||||
} |
|
||||||
|
|
||||||
uint32_t i = 0; |
|
||||||
auto consider_item = [&, this](const database::TrackId& item) { |
|
||||||
if (already_played_->Contains(item) || in_buffer.contains(item)) { |
|
||||||
return; |
|
||||||
} |
|
||||||
if (i < num_to_sample) { |
|
||||||
shuffled_items_buffer_.push_back(item); |
|
||||||
} else { |
|
||||||
uint32_t index_to_replace = random_->RangeInclusive(0, i); |
|
||||||
if (index_to_replace < num_to_sample) { |
|
||||||
shuffled_items_buffer_[resovoir_offset + index_to_replace] = item; |
|
||||||
} |
|
||||||
} |
|
||||||
i++; |
|
||||||
}; |
|
||||||
|
|
||||||
for (const Item& item : ordered_items_) { |
|
||||||
if (std::holds_alternative<database::TrackId>(item)) { |
|
||||||
std::invoke(consider_item, std::get<database::TrackId>(item)); |
|
||||||
} else { |
|
||||||
auto source = std::get<std::shared_ptr<IResetableSource>>(item); |
|
||||||
source->Reset(); |
|
||||||
while (source->Advance()) { |
|
||||||
std::invoke(consider_item, *source->Current()); |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
out_of_items_ = i > num_to_sample; |
|
||||||
// We've now got a random *selection*, but the order might be predictable
|
|
||||||
// (e.g. if there were only `num_to_sample` new items). Do a final in-memory
|
|
||||||
// shuffle.
|
|
||||||
std::random_shuffle(shuffled_items_buffer_.begin() + resovoir_offset, |
|
||||||
shuffled_items_buffer_.end()); |
|
||||||
} |
|
||||||
|
|
||||||
} // namespace playlist
|
|
||||||
@ -1,360 +0,0 @@ |
|||||||
/*
|
|
||||||
* Copyright 2023 jacqueline <me@jacqueline.id.au> |
|
||||||
* |
|
||||||
* SPDX-License-Identifier: GPL-3.0-only |
|
||||||
*/ |
|
||||||
|
|
||||||
#include "source.hpp" |
|
||||||
|
|
||||||
#include <algorithm> |
|
||||||
#include <functional> |
|
||||||
#include <memory> |
|
||||||
#include <set> |
|
||||||
#include <variant> |
|
||||||
|
|
||||||
#include "esp_log.h" |
|
||||||
|
|
||||||
#include "bloom_filter.hpp" |
|
||||||
#include "database.hpp" |
|
||||||
#include "komihash.h" |
|
||||||
#include "random.hpp" |
|
||||||
#include "track.hpp" |
|
||||||
|
|
||||||
namespace playlist { |
|
||||||
|
|
||||||
[[maybe_unused]] static constexpr char kTag[] = "queue_src"; |
|
||||||
|
|
||||||
IteratorSource::IteratorSource(const database::Iterator& it) |
|
||||||
: start_(it), current_(), next_() { |
|
||||||
Reset(); |
|
||||||
Advance(); |
|
||||||
} |
|
||||||
|
|
||||||
auto IteratorSource::Current() -> std::optional<database::TrackId> { |
|
||||||
return current_; |
|
||||||
} |
|
||||||
|
|
||||||
auto IteratorSource::Advance() -> std::optional<database::TrackId> { |
|
||||||
ESP_LOGI(kTag, "advancing"); |
|
||||||
while (!next_.empty()) { |
|
||||||
auto next = next_.top().NextSync(); |
|
||||||
if (!next) { |
|
||||||
ESP_LOGI(kTag, "top was empty"); |
|
||||||
next_.pop(); |
|
||||||
continue; |
|
||||||
} |
|
||||||
if (next->track()) { |
|
||||||
ESP_LOGI(kTag, "top held track %lu", next->track().value_or(0)); |
|
||||||
current_ = next->track(); |
|
||||||
return current_; |
|
||||||
} |
|
||||||
ESP_LOGI(kTag, "top held records"); |
|
||||||
next_.push(database::Iterator(start_.database(), next->Expand(1).value())); |
|
||||||
} |
|
||||||
ESP_LOGI(kTag, "exhausted"); |
|
||||||
return {}; |
|
||||||
} |
|
||||||
|
|
||||||
auto IteratorSource::Peek(std::size_t n, std::vector<database::TrackId>*) |
|
||||||
-> std::size_t { |
|
||||||
return 0; |
|
||||||
} |
|
||||||
|
|
||||||
auto IteratorSource::Previous() -> std::optional<database::TrackId> { |
|
||||||
return {}; |
|
||||||
} |
|
||||||
|
|
||||||
auto IteratorSource::Reset() -> void { |
|
||||||
while (!next_.empty()) { |
|
||||||
next_.pop(); |
|
||||||
} |
|
||||||
next_.push(start_); |
|
||||||
} |
|
||||||
|
|
||||||
auto CreateSourceFromResults( |
|
||||||
std::weak_ptr<database::Database> db, |
|
||||||
std::shared_ptr<database::Result<database::IndexRecord>> results) |
|
||||||
-> std::shared_ptr<IResetableSource> { |
|
||||||
if (results->values()[0]->track()) { |
|
||||||
return std::make_shared<IndexRecordSource>(db, results); |
|
||||||
} else { |
|
||||||
return std::make_shared<NestedSource>(db, results); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
IndexRecordSource::IndexRecordSource( |
|
||||||
std::weak_ptr<database::Database> db, |
|
||||||
std::shared_ptr<database::Result<database::IndexRecord>> initial) |
|
||||||
: db_(db), |
|
||||||
initial_page_(initial), |
|
||||||
initial_item_(0), |
|
||||||
current_page_(initial_page_), |
|
||||||
current_item_(initial_item_) {} |
|
||||||
|
|
||||||
IndexRecordSource::IndexRecordSource( |
|
||||||
std::weak_ptr<database::Database> db, |
|
||||||
std::shared_ptr<database::Result<database::IndexRecord>> initial, |
|
||||||
std::size_t initial_index, |
|
||||||
std::shared_ptr<database::Result<database::IndexRecord>> current, |
|
||||||
std::size_t current_index) |
|
||||||
: db_(db), |
|
||||||
initial_page_(initial), |
|
||||||
initial_item_(initial_index), |
|
||||||
current_page_(current), |
|
||||||
current_item_(current_index) {} |
|
||||||
|
|
||||||
auto IndexRecordSource::Current() -> std::optional<database::TrackId> { |
|
||||||
if (current_page_->values().size() <= current_item_) { |
|
||||||
return {}; |
|
||||||
} |
|
||||||
if (current_page_ == initial_page_ && current_item_ < initial_item_) { |
|
||||||
return {}; |
|
||||||
} |
|
||||||
|
|
||||||
return current_page_->values().at(current_item_)->track(); |
|
||||||
} |
|
||||||
|
|
||||||
auto IndexRecordSource::Advance() -> std::optional<database::TrackId> { |
|
||||||
current_item_++; |
|
||||||
if (current_item_ >= current_page_->values().size()) { |
|
||||||
auto next_page = current_page_->next_page(); |
|
||||||
if (!next_page) { |
|
||||||
current_item_--; |
|
||||||
return {}; |
|
||||||
} |
|
||||||
|
|
||||||
auto db = db_.lock(); |
|
||||||
if (!db) { |
|
||||||
return {}; |
|
||||||
} |
|
||||||
|
|
||||||
current_page_.reset(db->GetPage<database::IndexRecord>(&*next_page).get()); |
|
||||||
current_item_ = 0; |
|
||||||
} |
|
||||||
|
|
||||||
return Current(); |
|
||||||
} |
|
||||||
|
|
||||||
auto IndexRecordSource::Previous() -> std::optional<database::TrackId> { |
|
||||||
if (current_page_ == initial_page_ && current_item_ <= initial_item_) { |
|
||||||
return {}; |
|
||||||
} |
|
||||||
|
|
||||||
current_item_--; |
|
||||||
if (current_item_ < 0) { |
|
||||||
auto prev_page = current_page_->prev_page(); |
|
||||||
if (!prev_page) { |
|
||||||
return {}; |
|
||||||
} |
|
||||||
|
|
||||||
auto db = db_.lock(); |
|
||||||
if (!db) { |
|
||||||
return {}; |
|
||||||
} |
|
||||||
|
|
||||||
current_page_.reset(db->GetPage<database::IndexRecord>(&*prev_page).get()); |
|
||||||
current_item_ = current_page_->values().size() - 1; |
|
||||||
} |
|
||||||
|
|
||||||
return Current(); |
|
||||||
} |
|
||||||
|
|
||||||
auto IndexRecordSource::Peek(std::size_t n, std::vector<database::TrackId>* out) |
|
||||||
-> std::size_t { |
|
||||||
if (current_page_->values().size() <= current_item_) { |
|
||||||
return {}; |
|
||||||
} |
|
||||||
|
|
||||||
auto db = db_.lock(); |
|
||||||
if (!db) { |
|
||||||
return 0; |
|
||||||
} |
|
||||||
|
|
||||||
std::size_t items_added = 0; |
|
||||||
|
|
||||||
std::shared_ptr<database::Result<database::IndexRecord>> working_page = |
|
||||||
current_page_; |
|
||||||
std::size_t working_item = current_item_ + 1; |
|
||||||
|
|
||||||
while (n > 0) { |
|
||||||
if (working_item >= working_page->values().size()) { |
|
||||||
auto next_page = current_page_->next_page(); |
|
||||||
if (!next_page) { |
|
||||||
break; |
|
||||||
} |
|
||||||
// TODO(jacqueline): It would probably be a good idea to hold onto these
|
|
||||||
// peeked pages, to avoid needing to look them up again later.
|
|
||||||
working_page.reset(db->GetPage<database::IndexRecord>(&*next_page).get()); |
|
||||||
working_item = 0; |
|
||||||
} |
|
||||||
|
|
||||||
auto record = working_page->values().at(working_item); |
|
||||||
if (record->track()) { |
|
||||||
out->push_back(record->track().value()); |
|
||||||
n--; |
|
||||||
items_added++; |
|
||||||
} |
|
||||||
working_item++; |
|
||||||
} |
|
||||||
|
|
||||||
return items_added; |
|
||||||
} |
|
||||||
|
|
||||||
auto IndexRecordSource::Reset() -> void { |
|
||||||
current_page_ = initial_page_; |
|
||||||
current_item_ = initial_item_; |
|
||||||
} |
|
||||||
|
|
||||||
NestedSource::NestedSource( |
|
||||||
std::weak_ptr<database::Database> db, |
|
||||||
std::shared_ptr<database::Result<database::IndexRecord>> initial) |
|
||||||
: db_(db), |
|
||||||
initial_page_(initial), |
|
||||||
initial_item_(0), |
|
||||||
current_page_(initial_page_), |
|
||||||
current_item_(initial_item_), |
|
||||||
current_child_(CreateChild(initial->values()[0])) {} |
|
||||||
|
|
||||||
auto NestedSource::Current() -> std::optional<database::TrackId> { |
|
||||||
if (current_child_) { |
|
||||||
return current_child_->Current(); |
|
||||||
} |
|
||||||
return {}; |
|
||||||
} |
|
||||||
|
|
||||||
auto NestedSource::Advance() -> std::optional<database::TrackId> { |
|
||||||
if (!current_child_) { |
|
||||||
return {}; |
|
||||||
} |
|
||||||
|
|
||||||
auto child_next = current_child_->Advance(); |
|
||||||
if (child_next) { |
|
||||||
return child_next; |
|
||||||
} |
|
||||||
// Our current child has run out of tracks. Move on to the next child.
|
|
||||||
current_item_++; |
|
||||||
current_child_.reset(); |
|
||||||
|
|
||||||
if (current_item_ >= current_page_->values().size()) { |
|
||||||
// We're even out of items in this page!
|
|
||||||
auto next_page = current_page_->next_page(); |
|
||||||
if (!next_page) { |
|
||||||
current_item_--; |
|
||||||
return {}; |
|
||||||
} |
|
||||||
|
|
||||||
auto db = db_.lock(); |
|
||||||
if (!db) { |
|
||||||
return {}; |
|
||||||
} |
|
||||||
|
|
||||||
current_page_.reset(db->GetPage<database::IndexRecord>(&*next_page).get()); |
|
||||||
current_item_ = 0; |
|
||||||
} |
|
||||||
current_child_ = CreateChild(current_page_->values()[current_item_]); |
|
||||||
|
|
||||||
return Current(); |
|
||||||
} |
|
||||||
|
|
||||||
auto NestedSource::Previous() -> std::optional<database::TrackId> { |
|
||||||
if (current_page_ == initial_page_ && current_item_ <= initial_item_) { |
|
||||||
return {}; |
|
||||||
} |
|
||||||
|
|
||||||
current_item_--; |
|
||||||
current_child_.reset(); |
|
||||||
|
|
||||||
if (current_item_ < 0) { |
|
||||||
auto prev_page = current_page_->prev_page(); |
|
||||||
if (!prev_page) { |
|
||||||
return {}; |
|
||||||
} |
|
||||||
|
|
||||||
auto db = db_.lock(); |
|
||||||
if (!db) { |
|
||||||
return {}; |
|
||||||
} |
|
||||||
|
|
||||||
current_page_.reset(db->GetPage<database::IndexRecord>(&*prev_page).get()); |
|
||||||
current_item_ = current_page_->values().size() - 1; |
|
||||||
} |
|
||||||
current_child_ = CreateChild(current_page_->values()[current_item_]); |
|
||||||
|
|
||||||
return Current(); |
|
||||||
} |
|
||||||
|
|
||||||
auto NestedSource::Peek(std::size_t n, std::vector<database::TrackId>* out) |
|
||||||
-> std::size_t { |
|
||||||
if (current_page_->values().size() <= current_item_) { |
|
||||||
return {}; |
|
||||||
} |
|
||||||
|
|
||||||
auto db = db_.lock(); |
|
||||||
if (!db) { |
|
||||||
return 0; |
|
||||||
} |
|
||||||
|
|
||||||
std::size_t items_added = 0; |
|
||||||
|
|
||||||
std::shared_ptr<database::Result<database::IndexRecord>> working_page = |
|
||||||
current_page_; |
|
||||||
std::size_t working_item = current_item_; |
|
||||||
std::shared_ptr<IResetableSource> working_child = current_child_; |
|
||||||
|
|
||||||
while (working_child) { |
|
||||||
auto res = working_child->Peek(n, out); |
|
||||||
n -= res; |
|
||||||
items_added += res; |
|
||||||
|
|
||||||
if (n == 0) { |
|
||||||
break; |
|
||||||
} else { |
|
||||||
working_item++; |
|
||||||
if (working_item < working_page->values().size()) { |
|
||||||
working_child = CreateChild(working_page->values()[working_item]); |
|
||||||
} else { |
|
||||||
auto next_page = current_page_->next_page(); |
|
||||||
if (!next_page) { |
|
||||||
break; |
|
||||||
} |
|
||||||
working_page.reset( |
|
||||||
db->GetPage<database::IndexRecord>(&*next_page).get()); |
|
||||||
working_item = 0; |
|
||||||
working_child = CreateChild(working_page->values()[0]); |
|
||||||
} |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
return items_added; |
|
||||||
} |
|
||||||
|
|
||||||
auto NestedSource::Reset() -> void { |
|
||||||
current_page_ = initial_page_; |
|
||||||
current_item_ = initial_item_; |
|
||||||
current_child_ = CreateChild(initial_page_->values()[initial_item_]); |
|
||||||
} |
|
||||||
|
|
||||||
auto NestedSource::CreateChild(std::shared_ptr<database::IndexRecord> record) |
|
||||||
-> std::shared_ptr<IResetableSource> { |
|
||||||
auto cont = record->Expand(10); |
|
||||||
if (!cont) { |
|
||||||
return {}; |
|
||||||
} |
|
||||||
auto db = db_.lock(); |
|
||||||
if (!db) { |
|
||||||
return {}; |
|
||||||
} |
|
||||||
std::shared_ptr<database::Result<database::IndexRecord>> next_level{ |
|
||||||
db->GetPage<database::IndexRecord>(&*cont).get()}; |
|
||||||
if (!next_level) { |
|
||||||
return {}; |
|
||||||
} |
|
||||||
auto next_level_record = next_level->values()[0]; |
|
||||||
if (next_level_record->track()) { |
|
||||||
return std::make_shared<IndexRecordSource>(db_, next_level); |
|
||||||
} else { |
|
||||||
return std::make_shared<NestedSource>(db_, next_level); |
|
||||||
} |
|
||||||
} |
|
||||||
|
|
||||||
} // namespace playlist
|
|
||||||
Loading…
Reference in new issue