Add observation registry

Author: vadymmarkov

Source/Shared/Storage/HybridStorage.swift

@@ -1,11 +1,26 @@
 import Foundation
 
+protocol StorageChangeNotifier {
+  func notifyObservers(about change: StorageChange)
+}
+
+struct KeyChangeNotifier<T> {
+  
+
+  func notifyObserver(about change: KeyChange<T>, where closure: ((String) -> Bool)) {
+    
+  }
+}
+
+
 /// Use both memory and disk storage. Try on memory first.
 public final class HybridStorage<T> {
   public let memoryStorage: MemoryStorage<T>
   public let diskStorage: DiskStorage<T>
-  public let storageObservationRegistry = StorageObservationRegistry<HybridStorage>()
-  public let keyObservationRegistry = KeyObservationRegistry<HybridStorage>()
+  let storageObservationRegistry = ObservationRegistry<StorageChange>()
+  let keyObservationRegistry = ObservationRegistry<KeyChange<T>>()
+
+  var onKeyChange: ((KeyChange<T>, ((String) -> Bool)) -> Void)?
 
   public init(memoryStorage: MemoryStorage<T>, diskStorage: DiskStorage<T>) {
     self.memoryStorage = memoryStorage
@@ -17,7 +32,7 @@ public final class HybridStorage<T> {
   }
 
   private func handleRemovedObject(at path: String) {
-    keyObservationRegistry.notifyObserver(about: .remove, in: self) { key in
+    keyObservationRegistry.notifyObserver(about: .remove) { key in
       let fileName = diskStorage.makeFileName(for: key)
       return path.contains(fileName)
     }
@@ -40,7 +55,7 @@ extension HybridStorage: StorageAware {
     memoryStorage.removeObject(forKey: key)
     try diskStorage.removeObject(forKey: key)
 
-    storageObservationRegistry.notifyObservers(about: .remove(key: key), in: self)
+    storageObservationRegistry.notifyAllObservers(about: .remove(key: key))
   }
 
   public func setObject(_ object: T, forKey key: String, expiry: Expiry? = nil) throws {
@@ -55,25 +70,25 @@ extension HybridStorage: StorageAware {
 
 
     if let change = keyChange {
-      keyObservationRegistry.notifyObserver(forKey: key, about: change, in: self)
+      keyObservationRegistry.notifyObserver(forKey: key, about: change)
     }
 
-    storageObservationRegistry.notifyObservers(about: .add(key: key), in: self)
+    storageObservationRegistry.notifyAllObservers(about: .add(key: key))
   }
 
   public func removeAll() throws {
     memoryStorage.removeAll()
     try diskStorage.removeAll()
 
-    storageObservationRegistry.notifyObservers(about: .removeAll, in: self)
-    keyObservationRegistry.notifyAllObservers(about: .remove, in: self)
+    storageObservationRegistry.notifyAllObservers(about: .removeAll)
+    keyObservationRegistry.notifyAllObservers(about: .remove)
   }
 
   public func removeExpiredObjects() throws {
     memoryStorage.removeExpiredObjects()
     try diskStorage.removeExpiredObjects()
 
-    storageObservationRegistry.notifyObservers(about: .removeExpired, in: self)
+    storageObservationRegistry.notifyAllObservers(about: .removeExpired)
   }
 }
 

Source/Shared/Storage/KeyObservationRegistry.swift

@@ -3,6 +3,7 @@ import Foundation
 public final class KeyObservationRegistry<Storage: StorageAware> {
   public typealias Observation = (Storage, KeyChange<Storage.T>) -> Void
   private(set) var observations = [String: Observation]()
+  var onNewKey: ((String) -> Void)?
 
   public var isEmpty: Bool {
     return observations.isEmpty
@@ -11,6 +12,7 @@ public final class KeyObservationRegistry<Storage: StorageAware> {
   @discardableResult
   public func addObservation(_ observation: @escaping Observation, forKey key: String) -> ObservationToken {
     observations[key] = observation
+    onNewKey?(key)
 
     return ObservationToken { [weak self] in
       self?.observations.removeValue(forKey: key)
@@ -47,6 +49,13 @@ public final class KeyObservationRegistry<Storage: StorageAware> {
   }
 }
 
+// MARK: - Notification
+
+public struct KeyNotification<Storage: StorageAware> {
+  public let change: KeyChange<Storage.T>
+  public let storage: Storage
+}
+
 // MARK: - KeyChange
 
 public enum KeyChange<T> {
@@ -66,3 +75,47 @@ extension KeyChange: Equatable where T: Equatable {
     }
   }
 }
+
+
+
+
+
+final class ObservationRegistry<Change> {
+  typealias Observation = (Change) -> Void
+  private(set) var observations = [String: Observation]()
+
+  var isEmpty: Bool {
+    return observations.isEmpty
+  }
+
+  @discardableResult
+  func addObservation(forKey key: String = UUID().uuidString, _ observation: @escaping Observation) -> ObservationToken {
+    observations[key] = observation
+    return ObservationToken { [weak self] in
+      self?.observations.removeValue(forKey: key)
+    }
+  }
+
+  func removeObservation(forKey key: String) {
+    observations.removeValue(forKey: key)
+  }
+
+  func removeAllObservations() {
+    observations.removeAll()
+  }
+
+  func notifyObserver(forKey key: String, about change: Change) {
+    observations[key]?(change)
+  }
+
+  func notifyObserver(about change: Change, where closure: ((String) -> Bool)) {
+    let observation = observations.first { key, value in closure(key) }?.value
+    observation?(change)
+  }
+
+  func notifyAllObservers(about change: Change) {
+    observations.values.forEach { closure in
+      closure(change)
+    }
+  }
+}

Source/Shared/Storage/Storage.swift

@@ -5,8 +5,9 @@ import Dispatch
 /// Synchronous by default. Use `async` for asynchronous operations.
 public final class Storage<T> {
   /// Used for sync operations
-  let syncStorage: SyncStorage<T>
-  let asyncStorage: AsyncStorage<T>
+  private let syncStorage: SyncStorage<T>
+  private let asyncStorage: AsyncStorage<T>
+  private let hybridStorage: HybridStorage<T>
 
   public let storageObservationRegistry = StorageObservationRegistry<Storage>()
   public let keyObservationRegistry = KeyObservationRegistry<Storage>()
@@ -20,45 +21,41 @@ public final class Storage<T> {
   public convenience init(diskConfig: DiskConfig, memoryConfig: MemoryConfig, transformer: Transformer<T>) throws {
     let disk = try DiskStorage(config: diskConfig, transformer: transformer)
     let memory = MemoryStorage<T>(config: memoryConfig)
-
     let hybridStorage = HybridStorage(memoryStorage: memory, diskStorage: disk)
-    let syncStorage = SyncStorage(
-      storage: hybridStorage,
-      serialQueue: DispatchQueue(label: "Cache.SyncStorage.SerialQueue")
-    )
-    let asyncStorage = AsyncStorage(
-      storage: hybridStorage,
-      serialQueue: DispatchQueue(label: "Cache.AsyncStorage.SerialQueue")
-    )
-
-    self.init(syncStorage: syncStorage, asyncStorage: asyncStorage)
+    self.init(hybridStorage: hybridStorage)
   }
 
   /// Initialise with sync and async storages
   ///
   /// - Parameter syncStorage: Synchronous storage
   /// - Paraeter: asyncStorage: Asynchronous storage
-  public required init(syncStorage: SyncStorage<T>, asyncStorage: AsyncStorage<T>) {
-    self.syncStorage = syncStorage
-    self.asyncStorage = asyncStorage
-    subscribeToChanges()
+  public init(hybridStorage: HybridStorage<T>) {
+    self.hybridStorage = hybridStorage
+    self.syncStorage = SyncStorage(
+      storage: hybridStorage,
+      serialQueue: DispatchQueue(label: "Cache.SyncStorage.SerialQueue")
+    )
+    self.asyncStorage = AsyncStorage(
+      storage: hybridStorage,
+      serialQueue: DispatchQueue(label: "Cache.AsyncStorage.SerialQueue")
+    )
+    subscribeToChanges(in: hybridStorage)
   }
 
   /// Used for async operations
   public lazy var async = self.asyncStorage
 
-  private func subscribeToChanges() {
-    subscribeToChanges(in: syncStorage.innerStorage)
-    if syncStorage.innerStorage !== asyncStorage.innerStorage {
-      subscribeToChanges(in: asyncStorage.innerStorage)
-    }
-  }
-
   private func subscribeToChanges(in storage: HybridStorage<T>) {
     storage.storageObservationRegistry.addObservation { [weak self] _, change in
       guard let strongSelf = self else { return }
       strongSelf.storageObservationRegistry.notifyObservers(about: change, in: strongSelf)
     }
+    keyObservationRegistry.onNewKey = { [weak self] key in
+      guard let strongSelf = self else { return }
+      storage.keyObservationRegistry.addObservation({ _, change in
+        strongSelf.keyObservationRegistry.notifyObserver(forKey: key, about: change, in: strongSelf)
+      }, forKey: key)
+    }
   }
 }
 
@@ -86,10 +83,6 @@ extension Storage: StorageAware {
 
 public extension Storage {
   func transform<U>(transformer: Transformer<U>) -> Storage<U> {
-    let storage = Storage<U>(
-      syncStorage: syncStorage.transform(transformer: transformer),
-      asyncStorage: asyncStorage.transform(transformer: transformer)
-    )
-    return storage
+    return Storage<U>(hybridStorage: hybridStorage.transform(transformer: transformer))
   }
 }

Source/Shared/Storage/StorageObservationRegistry.swift

@@ -2,7 +2,7 @@ import Foundation
 
 public final class StorageObservationRegistry<Storage: StorageAware> {
   public typealias Observation = (Storage, StorageChange) -> Void
-  private(set) var observations = [UUID: Observation]()
+  private(set) var observations = [UUID: Observation]() 
 
   public var isEmpty: Bool {
     return observations.isEmpty