Implement the createMap and createCounter methods

TODO test

haven't done mode checking

Author: lawrence-forooghian

Sources/AblyLiveObjects/Internal/InternalDefaultRealtimeObjects.swift

@@ -164,20 +164,87 @@ internal final class InternalDefaultRealtimeObjects: Sendable, LiveMapObjectPool
         }
     }
 
-    internal func createMap(entries _: [String: LiveMapValue]) async throws(ARTErrorInfo) -> any LiveMap {
-        notYetImplemented()
+    internal func createMap(entries: [String: LiveMapValue], coreSDK: CoreSDK) async throws(ARTErrorInfo) -> any LiveMap {
+        do {
+            let internalEntries: [String: InternalLiveMapValue] = entries.mapValues { .init(liveMapValue: $0) }
+
+            // RTO11f
+            // TODO: This is a stopgap; change to use server time per RTO11f5
+            let timestamp = clock.now
+            let creationOperation = ObjectCreationHelpers.creationOperationForLiveMap(
+                entries: internalEntries,
+                timestamp: timestamp,
+            )
+
+            // RTO11g
+            try await coreSDK.sendObject(objectMessages: [creationOperation.objectMessage])
+
+            // RTO11h
+            let internalMap = mutex.withLock {
+                mutableState.objectsPool.getOrCreateMap(
+                    creationOperation: creationOperation,
+                    logger: logger,
+                    userCallbackQueue: userCallbackQueue,
+                    clock: clock,
+                )
+            }
+
+            return PublicObjectsStore.shared.getOrCreateMap(
+                proxying: internalMap,
+                creationArgs: .init(
+                    coreSDK: coreSDK,
+                    delegate: self,
+                    logger: logger,
+                ),
+            )
+        } catch {
+            throw error.toARTErrorInfo()
+        }
     }
 
-    internal func createMap() async throws(ARTErrorInfo) -> any LiveMap {
-        notYetImplemented()
+    internal func createMap(coreSDK: CoreSDK) async throws(ARTErrorInfo) -> any LiveMap {
+        // RTO11f4b
+        try await createMap(entries: [:], coreSDK: coreSDK)
     }
 
-    internal func createCounter(count _: Double) async throws(ARTErrorInfo) -> any LiveCounter {
-        notYetImplemented()
+    internal func createCounter(count: Double, coreSDK: CoreSDK) async throws(ARTErrorInfo) -> any LiveCounter {
+        do {
+            // RTO12f
+            // TODO: This is a stopgap; change to use server time per RTO12f5
+            let timestamp = clock.now
+            let creationOperation = ObjectCreationHelpers.creationOperationForLiveCounter(
+                count: count,
+                timestamp: timestamp,
+            )
+
+            // RTO12g
+            try await coreSDK.sendObject(objectMessages: [creationOperation.objectMessage])
+
+            // RTO12h
+            let internalCounter = mutex.withLock {
+                mutableState.objectsPool.getOrCreateCounter(
+                    creationOperation: creationOperation,
+                    logger: logger,
+                    userCallbackQueue: userCallbackQueue,
+                    clock: clock,
+                )
+            }
+
+            return PublicObjectsStore.shared.getOrCreateCounter(
+                proxying: internalCounter,
+                creationArgs: .init(
+                    coreSDK: coreSDK,
+                    logger: logger,
+                ),
+            )
+        } catch {
+            throw error.toARTErrorInfo()
+        }
     }
 
-    internal func createCounter() async throws(ARTErrorInfo) -> any LiveCounter {
-        notYetImplemented()
+    internal func createCounter(coreSDK: CoreSDK) async throws(ARTErrorInfo) -> any LiveCounter {
+        // RTO12f2a
+        try await createCounter(count: 0, coreSDK: coreSDK)
     }
 
     internal func batch(callback _: sending BatchCallback) async throws {

Sources/AblyLiveObjects/Internal/InternalLiveMapValue.swift

@@ -6,6 +6,30 @@ internal enum InternalLiveMapValue: Sendable, Equatable {
     case liveMap(InternalDefaultLiveMap)
     case liveCounter(InternalDefaultLiveCounter)
 
+    // MARK: - Creating from a public LiveMapValue
+
+    /// Converts a public ``LiveMapValue`` into an ``InternalLiveMapValue``.
+    ///
+    /// Needed in order to access the internals of user-provided LiveObject-valued LiveMap entries to extract their object ID.
+    internal init(liveMapValue: LiveMapValue) {
+        switch liveMapValue {
+        case let .primitive(primitiveValue):
+            self = .primitive(primitiveValue)
+        case let .liveMap(publicLiveMap):
+            guard let publicDefaultLiveMap = publicLiveMap as? PublicDefaultLiveMap else {
+                // TODO: Try and remove this runtime check and know this type statically, see https://github.com/ably/ably-cocoa-liveobjects-plugin/issues/37
+                preconditionFailure("Expected PublicDefaultLiveMap, got \(publicLiveMap)")
+            }
+            self = .liveMap(publicDefaultLiveMap.proxied)
+        case let .liveCounter(publicLiveCounter):
+            guard let publicDefaultLiveCounter = publicLiveCounter as? PublicDefaultLiveCounter else {
+                // TODO: Try and remove this runtime check and know this type statically, see https://github.com/ably/ably-cocoa-liveobjects-plugin/issues/37
+                preconditionFailure("Expected PublicDefaultLiveCounter, got \(publicLiveCounter)")
+            }
+            self = .liveCounter(publicDefaultLiveCounter.proxied)
+        }
+    }
+
     // MARK: - Representation in the Realtime protocol
 
     // TODO: document — it's RTO11f4 (for createMap) and RTLM20e4 (for set)

Sources/AblyLiveObjects/Public/Public Proxy Objects/PublicDefaultRealtimeObjects.swift

@@ -36,19 +36,19 @@ internal final class PublicDefaultRealtimeObjects: RealtimeObjects {
     }
 
     internal func createMap(entries: [String: LiveMapValue]) async throws(ARTErrorInfo) -> any LiveMap {
-        try await proxied.createMap(entries: entries)
+        try await proxied.createMap(entries: entries, coreSDK: coreSDK)
     }
 
     internal func createMap() async throws(ARTErrorInfo) -> any LiveMap {
-        try await proxied.createMap()
+        try await proxied.createMap(coreSDK: coreSDK)
     }
 
     internal func createCounter(count: Double) async throws(ARTErrorInfo) -> any LiveCounter {
-        try await proxied.createCounter(count: count)
+        try await proxied.createCounter(count: count, coreSDK: coreSDK)
     }
 
     internal func createCounter() async throws(ARTErrorInfo) -> any LiveCounter {
-        try await proxied.createCounter()
+        try await proxied.createCounter(coreSDK: coreSDK)
     }
 
     internal func batch(callback: sending BatchCallback) async throws {