Clean up LibraryItem (#9072)

* Move LibraryItem vars to constructor vals

* Convert LibraryItem to data class

Remove redundant equals and hashCode

* Remove unused LibraryItem.displayMode

* Simplify LibraryItem.matches()

* Align types in LibraryItem and LibraryBadges

* fixup! Simplify LibraryItem.matches()

app/src/main/java/eu/kanade/presentation/library/components/LibraryBadges.kt

@@ -7,7 +7,7 @@ import eu.kanade.presentation.components.Badge
 import eu.kanade.tachiyomi.R
 
 @Composable
-fun DownloadsBadge(count: Int) {
+fun DownloadsBadge(count: Long) {
     if (count > 0) {
         Badge(
             text = "$count",
@@ -18,7 +18,7 @@ fun DownloadsBadge(count: Int) {
 }
 
 @Composable
-fun UnreadBadge(count: Int) {
+fun UnreadBadge(count: Long) {
     if (count > 0) {
         Badge(text = "$count")
     }

app/src/main/java/eu/kanade/presentation/library/components/LibraryComfortableGrid.kt

@@ -46,8 +46,8 @@ fun LibraryComfortableGrid(
                     lastModified = manga.coverLastModified,
                 ),
                 coverBadgeStart = {
-                    DownloadsBadge(count = libraryItem.downloadCount.toInt())
+                    DownloadsBadge(count = libraryItem.downloadCount)
-                    UnreadBadge(count = libraryItem.unreadCount.toInt())
+                    UnreadBadge(count = libraryItem.unreadCount)
                 },
                 coverBadgeEnd = {
                     LanguageBadge(

app/src/main/java/eu/kanade/presentation/library/components/LibraryCompactGrid.kt

@@ -47,8 +47,8 @@ fun LibraryCompactGrid(
                     lastModified = manga.coverLastModified,
                 ),
                 coverBadgeStart = {
-                    DownloadsBadge(count = libraryItem.downloadCount.toInt())
+                    DownloadsBadge(count = libraryItem.downloadCount)
-                    UnreadBadge(count = libraryItem.unreadCount.toInt())
+                    UnreadBadge(count = libraryItem.unreadCount)
                 },
                 coverBadgeEnd = {
                     LanguageBadge(

app/src/main/java/eu/kanade/presentation/library/components/LibraryList.kt

@@ -56,8 +56,8 @@ fun LibraryList(
                     lastModified = manga.coverLastModified,
                 ),
                 badge = {
-                    DownloadsBadge(count = libraryItem.downloadCount.toInt())
+                    DownloadsBadge(count = libraryItem.downloadCount)
-                    UnreadBadge(count = libraryItem.unreadCount.toInt())
+                    UnreadBadge(count = libraryItem.unreadCount)
                     LanguageBadge(
                         isLocal = libraryItem.isLocal,
                         sourceLanguage = libraryItem.sourceLanguage,

app/src/main/java/eu/kanade/tachiyomi/ui/library/LibraryItem.kt

@@ -6,17 +6,14 @@ import tachiyomi.domain.library.model.LibraryManga
 import uy.kohesive.injekt.Injekt
 import uy.kohesive.injekt.api.get
 
-class LibraryItem(
+data class LibraryItem(
     val libraryManga: LibraryManga,
+    val downloadCount: Long = -1,
+    val unreadCount: Long = -1,
+    val isLocal: Boolean = false,
+    val sourceLanguage: String = "",
     private val sourceManager: SourceManager = Injekt.get(),
 ) {
-
-    var displayMode: Long = -1
-    var downloadCount: Long = -1
-    var unreadCount: Long = -1
-    var isLocal = false
-    var sourceLanguage = ""
-
     /**
      * Checks if a query matches the manga
      *
@@ -25,73 +22,34 @@ class LibraryItem(
      */
     fun matches(constraint: String): Boolean {
         val sourceName by lazy { sourceManager.getOrStub(libraryManga.manga.source).getNameForMangaInfo() }
-        val genres by lazy { libraryManga.manga.genre }
         return libraryManga.manga.title.contains(constraint, true) ||
             (libraryManga.manga.author?.contains(constraint, true) ?: false) ||
             (libraryManga.manga.artist?.contains(constraint, true) ?: false) ||
             (libraryManga.manga.description?.contains(constraint, true) ?: false) ||
-            if (constraint.contains(",")) {
+            constraint.split(",").map { it.trim() }.all { subconstraint ->
-                constraint.split(",").all { containsSourceOrGenre(it.trim(), sourceName, genres) }
+                checkNegatableConstraint(subconstraint) {
-            } else {
+                    sourceName.contains(it, true) ||
-                containsSourceOrGenre(constraint, sourceName, genres)
+                        (libraryManga.manga.genre?.any { genre -> genre.equals(it, true) } ?: false)
+                }
             }
     }
 
     /**
-     * Filters a manga by checking whether the query is the manga's source OR part of
+     * Checks a predicate on a negatable constraint. If the constraint starts with a minus character,
-     * the genres of the manga
+     * the minus is stripped and the result of the predicate is inverted.
-     * Checking for genre is done only if the query isn't part of the source name.
      *
-     * @param query the query to check
+     * @param constraint the argument to the predicate. Inverts the predicate if it starts with '-'.
-     * @param sourceName name of the manga's source
+     * @param predicate the check to be run against the constraint.
-     * @param genres list containing manga's genres
+     * @return !predicate(x) if constraint = "-x", otherwise predicate(constraint)
      */
-    private fun containsSourceOrGenre(query: String, sourceName: String, genres: List<String>?): Boolean {
+    private fun checkNegatableConstraint(
-        val minus = query.startsWith("-")
+        constraint: String,
-        val tag = if (minus) { query.substringAfter("-") } else query
+        predicate: (String) -> Boolean,
-        return when (sourceName.contains(tag, true)) {
+    ): Boolean {
-            false -> containsGenre(query, genres)
+        return if (constraint.startsWith("-")) {
-            else -> !minus
+            !predicate(constraint.substringAfter("-").trimStart())
-        }
-    }
-
-    private fun containsGenre(tag: String, genres: List<String>?): Boolean {
-        return if (tag.startsWith("-")) {
-            genres?.find {
-                it.trim().equals(tag.substringAfter("-"), ignoreCase = true)
-            } == null
         } else {
-            genres?.find {
+            predicate(constraint)
-                it.trim().equals(tag, ignoreCase = true)
-            } != null
         }
     }
-
-    override fun equals(other: Any?): Boolean {
-        if (this === other) return true
-        if (javaClass != other?.javaClass) return false
-
-        other as LibraryItem
-
-        if (libraryManga != other.libraryManga) return false
-        if (sourceManager != other.sourceManager) return false
-        if (displayMode != other.displayMode) return false
-        if (downloadCount != other.downloadCount) return false
-        if (unreadCount != other.unreadCount) return false
-        if (isLocal != other.isLocal) return false
-        if (sourceLanguage != other.sourceLanguage) return false
-
-        return true
-    }
-
-    override fun hashCode(): Int {
-        var result = libraryManga.hashCode()
-        result = 31 * result + sourceManager.hashCode()
-        result = 31 * result + displayMode.hashCode()
-        result = 31 * result + downloadCount.toInt()
-        result = 31 * result + unreadCount.toInt()
-        result = 31 * result + isLocal.hashCode()
-        result = 31 * result + sourceLanguage.hashCode()
-        return result
-    }
 }

app/src/main/java/eu/kanade/tachiyomi/ui/library/LibraryScreenModel.kt

@@ -371,20 +371,21 @@ class LibraryScreenModel(
             libraryMangaList
                 .map { libraryManga ->
                     // Display mode based on user preference: take it from global library setting or category
-                    LibraryItem(libraryManga).apply {
+                    LibraryItem(
+                        libraryManga,
                         downloadCount = if (prefs.downloadBadge) {
                             downloadManager.getDownloadCount(libraryManga.manga).toLong()
                         } else {
                             0
-                        }
+                        },
-                        unreadCount = libraryManga.unreadCount
+                        unreadCount = libraryManga.unreadCount,
-                        isLocal = if (prefs.localBadge) libraryManga.manga.isLocal() else false
+                        isLocal = if (prefs.localBadge) libraryManga.manga.isLocal() else false,
                         sourceLanguage = if (prefs.languageBadge) {
                             sourceManager.getOrStub(libraryManga.manga.source).lang
                         } else {
                             ""
-                        }
+                        },
-                    }
+                    )
                 }
                 .groupBy { it.libraryManga.category }
         }