Use bindey for databinding instead of hand rolling ui updates

4 files changed, 46 insertions, 41 deletions

diff --git a/src/database/include/database.hpp b/src/database/include/database.hpp
index 98540f41..6ad8d318 100644
--- a/src/database/include/database.hpp
+++ b/src/database/include/database.hpp
@@ -48,12 +48,14 @@ struct Continuation {
 template <typename T>
 class Result {
  public:
-  auto values() const -> const std::vector<T>& { return values_; }
+  auto values() const -> const std::vector<std::shared_ptr<T>>& {
+    return values_;
+  }
 
   auto next_page() -> std::optional<Continuation<T>>& { return next_page_; }
   auto prev_page() -> std::optional<Continuation<T>>& { return prev_page_; }
 
-  Result(const std::vector<T>&& values,
+  Result(const std::vector<std::shared_ptr<T>>&& values,
          std::optional<Continuation<T>> next,
          std::optional<Continuation<T>> prev)
       : values_(values), next_page_(next), prev_page_(prev) {}
@@ -62,7 +64,7 @@ class Result {
   Result& operator=(const Result&) = delete;
 
  private:
-  std::vector<T> values_;
+  std::vector<std::shared_ptr<T>> values_;
   std::optional<Continuation<T>> next_page_;
   std::optional<Continuation<T>> prev_page_;
 };
@@ -102,14 +104,14 @@ class Database {
 
   auto GetTrackPath(TrackId id) -> std::future<std::optional<std::pmr::string>>;
 
-  auto GetTrack(TrackId id) -> std::future<std::optional<Track>>;
+  auto GetTrack(TrackId id) -> std::future<std::shared_ptr<Track>>;
 
   /*
    * Fetches data for multiple tracks more efficiently than multiple calls to
    * GetTrack.
    */
   auto GetBulkTracks(std::vector<TrackId> id)
-      -> std::future<std::vector<std::optional<Track>>>;
+      -> std::future<std::vector<std::shared_ptr<Track>>>;
 
   auto GetIndexes() -> std::vector<IndexInfo>;
   auto GetTracksByIndex(const IndexInfo& index, std::size_t page_size)
@@ -145,30 +147,30 @@ class Database {
   auto dbEntomb(TrackId track, uint64_t hash) -> void;
 
   auto dbPutTrackData(const TrackData& s) -> void;
-  auto dbGetTrackData(TrackId id) -> std::optional<TrackData>;
+  auto dbGetTrackData(TrackId id) -> std::shared_ptr<TrackData>;
   auto dbPutHash(const uint64_t& hash, TrackId i) -> void;
   auto dbGetHash(const uint64_t& hash) -> std::optional<TrackId>;
-  auto dbCreateIndexesForTrack(Track track) -> void;
+  auto dbCreateIndexesForTrack(const Track& track) -> void;
 
   template <typename T>
   auto dbGetPage(const Continuation<T>& c) -> Result<T>*;
 
   template <typename T>
   auto ParseRecord(const leveldb::Slice& key, const leveldb::Slice& val)
-      -> std::optional<T>;
+      -> std::shared_ptr<T>;
 };
 
 template <>
 auto Database::ParseRecord<IndexRecord>(const leveldb::Slice& key,
                                         const leveldb::Slice& val)
-    -> std::optional<IndexRecord>;
+    -> std::shared_ptr<IndexRecord>;
 template <>
 auto Database::ParseRecord<Track>(const leveldb::Slice& key,
                                   const leveldb::Slice& val)
-    -> std::optional<Track>;
+    -> std::shared_ptr<Track>;
 template <>
 auto Database::ParseRecord<std::pmr::string>(const leveldb::Slice& key,
                                              const leveldb::Slice& val)
-    -> std::optional<std::pmr::string>;
+    -> std::shared_ptr<std::pmr::string>;
 
 }  // namespace database
diff --git a/src/database/include/records.hpp b/src/database/include/records.hpp
index b144dece..e7d7738c 100644
--- a/src/database/include/records.hpp
+++ b/src/database/include/records.hpp
@@ -53,7 +53,7 @@ auto EncodeDataValue(const TrackData& track) -> OwningSlice;
  * Parses bytes previously encoded via EncodeDataValue back into a TrackData.
  * May return nullopt if parsing fails.
  */
-auto ParseDataValue(const leveldb::Slice& slice) -> std::optional<TrackData>;
+auto ParseDataValue(const leveldb::Slice& slice) -> std::shared_ptr<TrackData>;
 
 /* Encodes a hash key for the specified hash. */
 auto EncodeHashKey(const uint64_t& hash) -> OwningSlice;
diff --git a/src/database/include/tag_parser.hpp b/src/database/include/tag_parser.hpp
index d77967d8..04817c59 100644
--- a/src/database/include/tag_parser.hpp
+++ b/src/database/include/tag_parser.hpp
@@ -16,21 +16,21 @@ namespace database {
 class ITagParser {
  public:
   virtual ~ITagParser() {}
-  virtual auto ReadAndParseTags(const std::pmr::string& path, TrackTags* out)
-      -> bool = 0;
+  virtual auto ReadAndParseTags(const std::pmr::string& path)
+      -> std::shared_ptr<TrackTags> = 0;
 };
 
 class GenericTagParser : public ITagParser {
  public:
-  auto ReadAndParseTags(const std::pmr::string& path, TrackTags* out)
-      -> bool override;
+  auto ReadAndParseTags(const std::pmr::string& path)
+      -> std::shared_ptr<TrackTags> override;
 };
 
 class TagParserImpl : public ITagParser {
  public:
   TagParserImpl();
-  auto ReadAndParseTags(const std::pmr::string& path, TrackTags* out)
-      -> bool override;
+  auto ReadAndParseTags(const std::pmr::string& path)
+      -> std::shared_ptr<TrackTags> override;
 
  private:
   std::map<std::pmr::string, std::unique_ptr<ITagParser>> extension_to_parser_;
@@ -41,7 +41,7 @@ class TagParserImpl : public ITagParser {
    * cache should be slightly larger than any page sizes in the UI.
    */
   std::mutex cache_mutex_;
-  util::LruCache<16, std::pmr::string, TrackTags> cache_;
+  util::LruCache<16, std::pmr::string, std::shared_ptr<TrackTags>> cache_;
 
   // We could also consider keeping caches of artist name -> std::pmr::string
   // and similar. This hasn't been done yet, as this isn't a common workload in
@@ -50,8 +50,8 @@ class TagParserImpl : public ITagParser {
 
 class OpusTagParser : public ITagParser {
  public:
-  auto ReadAndParseTags(const std::pmr::string& path, TrackTags* out)
-      -> bool override;
+  auto ReadAndParseTags(const std::pmr::string& path)
+      -> std::shared_ptr<TrackTags> override;
 };
 
 }  // namespace database
diff --git a/src/database/include/track.hpp b/src/database/include/track.hpp
index 1c11ddea..3c7b20fa 100644
--- a/src/database/include/track.hpp
+++ b/src/database/include/track.hpp
@@ -61,12 +61,17 @@ enum class Tag {
  */
 class TrackTags {
  public:
-  auto encoding() const -> Container { return encoding_; };
-  auto encoding(Container e) -> void { encoding_ = e; };
-
   TrackTags()
       : encoding_(Container::kUnsupported), tags_(&memory::kSpiRamResource) {}
 
+  TrackTags(const TrackTags& other) = delete;
+  TrackTags& operator=(TrackTags& other) = delete;
+
+  bool operator==(const TrackTags&) const = default;
+
+  auto encoding() const -> Container { return encoding_; };
+  auto encoding(Container e) -> void { encoding_ = e; };
+
   std::optional<int> channels;
   std::optional<int> sample_rate;
   std::optional<int> bits_per_sample;
@@ -85,10 +90,6 @@ class TrackTags {
    */
   auto Hash() const -> uint64_t;
 
-  bool operator==(const TrackTags&) const = default;
-  TrackTags& operator=(const TrackTags&) = default;
-  TrackTags(const TrackTags&) = default;
-
  private:
   Container encoding_;
   std::pmr::unordered_map<Tag, std::pmr::string> tags_;
@@ -139,6 +140,11 @@ class TrackData {
         play_count_(play_count),
         is_tombstoned_(is_tombstoned) {}
 
+  TrackData(TrackData&& other) = delete;
+  TrackData& operator=(TrackData& other) = delete;
+
+  bool operator==(const TrackData&) const = default;
+
   auto id() const -> TrackId { return id_; }
   auto filepath() const -> std::pmr::string { return filepath_; }
   auto play_count() const -> uint32_t { return play_count_; }
@@ -158,8 +164,6 @@ class TrackData {
    * new location.
    */
   auto Exhume(const std::pmr::string& new_path) const -> TrackData;
-
-  bool operator==(const TrackData&) const = default;
 };
 
 /*
@@ -172,23 +176,22 @@ class TrackData {
  */
 class Track {
  public:
-  Track(const TrackData& data, const TrackTags& tags)
+  Track(std::shared_ptr<TrackData>& data, std::shared_ptr<TrackTags> tags)
       : data_(data), tags_(tags) {}
-  Track(const Track& other) = default;
 
-  auto data() const -> const TrackData& { return data_; }
-  auto tags() const -> const TrackTags& { return tags_; }
-
-  auto TitleOrFilename() const -> std::pmr::string;
+  Track(Track& other) = delete;
+  Track& operator=(Track& other) = delete;
 
   bool operator==(const Track&) const = default;
-  Track operator=(const Track& other) const { return Track(other); }
+
+  auto data() const -> const TrackData& { return *data_; }
+  auto tags() const -> const TrackTags& { return *tags_; }
+
+  auto TitleOrFilename() const -> std::pmr::string;
 
  private:
-  const TrackData data_;
-  const TrackTags tags_;
+  std::shared_ptr<TrackData> data_;
+  std::shared_ptr<TrackTags> tags_;
 };
 
-void swap(Track& first, Track& second);
-
 }  // namespace database