Full generation, file type cleanup

CHDataManagement/Model/Item/ItemId.swift

@@ -1,8 +1,6 @@
 
 struct ItemId {
 
-    let itemId: String
-
     let language: ContentLanguage
 
     let itemType: ItemType
@@ -11,16 +9,16 @@ struct ItemId {
 extension ItemId: Equatable {
 
     static func == (lhs: ItemId, rhs: ItemId) -> Bool {
-        lhs.itemId == rhs.itemId && lhs.language == rhs.language && lhs.itemType == rhs.itemType
+        lhs.language == rhs.language &&
+        lhs.itemType == rhs.itemType
     }
 }
 
 extension ItemId: Hashable {
 
     func hash(into hasher: inout Hasher) {
-        hasher.combine(itemId)
         hasher.combine(language)
-        hasher.combine(itemType)
+        hasher.combine(itemType.id)
     }
 }
 
@@ -30,9 +28,6 @@ extension ItemId: Comparable {
         guard lhs.itemType == rhs.itemType else {
             return lhs.itemType < rhs.itemType
         }
-        guard lhs.itemId == rhs.itemId else {
-            return lhs.itemId < rhs.itemId
-        }
         return lhs.language < rhs.language
     }
 }

CHDataManagement/Model/Item/ItemType.swift

@@ -1,15 +1,17 @@
 
-enum ItemType: String, Codable {
+enum ItemType {
 
-    case post
+    case general
 
-    case tag
+    case post(Post)
 
-    case page
+    case feed
+
+    case page(Page)
+
+    case tagPage(Tag)
 
     case tagOverview
-
-    case file
 }
 
 extension ItemType: Equatable {
@@ -23,13 +25,52 @@ extension ItemType: Hashable {
 extension ItemType: Identifiable {
 
     var id: String {
-        rawValue
+        switch self {
+        case .general:
+            return "0-general"
+        case .feed:
+            return "1-feed"
+        case .post(let post):
+            return "2-post-\(post.id)"
+        case .page(let page):
+            return "3-page-\(page.id)"
+        case .tagPage(let tag):
+            return "5-tag-\(tag.id)"
+        case .tagOverview:
+            return "4-tag-overview"
+        }
+    }
+
+    init?(rawValue: String, posts: [String : Post], pages: [String : Page], tags: [String : Tag]) {
+        if rawValue == "0-general" {
+            self = .general
+        } else if rawValue == "1-feed" {
+            self = .feed
+        } else if rawValue == "4-tag-overview" {
+            self = .tagOverview
+        } else if let id = rawValue.removingPrefix("3-page-"), let page = pages[id] {
+            self = .page(page)
+        } else if let id = rawValue.removingPrefix("2-post-"), let post = posts[id] {
+            self = .post(post)
+        } else if let id = rawValue.removingPrefix("5-tag-"), let tag = tags[id] {
+            self = .tagPage(tag)
+        } else {
+            return nil
+        }
     }
 }
 
 extension ItemType: Comparable {
 
     static func < (lhs: ItemType, rhs: ItemType) -> Bool {
-        lhs.rawValue < rhs.rawValue
+        lhs.id < rhs.id
+    }
+}
+
+extension String {
+
+    func removingPrefix(_ prefix: String) -> String? {
+        guard self.hasPrefix(prefix) else { return nil }
+        return String(self.dropFirst(prefix.count))
     }
 }