mirror of
https://github.com/Novaloop-AG/element-x-ios.git
synced 2026-11-02 03:06:37 +00:00
Stefan Ceriu
5851100f07
Wrap the SDK's SearchService in a SearchServiceProxy that publishes typed message results and paginates on demand, expose it on the ClientProxy, and enable the search index store on the session. Also opens up the timeline item factory's message content builder so the proxy can reuse it.
18659 lines
1.0 MiB
Plaintext
18659 lines
1.0 MiB
Plaintext
// Generated using Sourcery 2.3.0 — https://github.com/krzysztofzablocki/Sourcery
|
|
// DO NOT EDIT
|
|
|
|
// swiftlint:disable all
|
|
@preconcurrency import MatrixRustSDK
|
|
|
|
import Foundation
|
|
|
|
open class BackupSecretsSDKMock: MatrixRustSDK.BackupSecrets, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
}
|
|
open class CheckCodeSenderSDKMock: MatrixRustSDK.CheckCodeSender, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
|
|
//MARK: - send
|
|
|
|
open var sendCodeThrowableError: Error?
|
|
private let sendCodeCallsCountLock = NSLock()
|
|
private var sendCodeUnderlyingCallsCount = 0
|
|
open var sendCodeCallsCount: Int {
|
|
get { sendCodeCallsCountLock.withLock { sendCodeUnderlyingCallsCount } }
|
|
set { sendCodeCallsCountLock.withLock { sendCodeUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var sendCodeCalled: Bool {
|
|
return sendCodeCallsCount > 0
|
|
}
|
|
private let sendCodeReceivedCodeLock = NSLock()
|
|
private var sendCodeUnderlyingReceivedCode: UInt8?
|
|
open var sendCodeReceivedCode: UInt8? {
|
|
get { sendCodeReceivedCodeLock.withLock { sendCodeUnderlyingReceivedCode } }
|
|
set { sendCodeReceivedCodeLock.withLock { sendCodeUnderlyingReceivedCode = newValue } }
|
|
}
|
|
private let sendCodeReceivedInvocationsLock = NSLock()
|
|
private var sendCodeUnderlyingReceivedInvocations: [UInt8] = []
|
|
open var sendCodeReceivedInvocations: [UInt8] {
|
|
get { sendCodeReceivedInvocationsLock.withLock { sendCodeUnderlyingReceivedInvocations } }
|
|
set { sendCodeReceivedInvocationsLock.withLock { sendCodeUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var sendCodeClosure: ((UInt8) async throws -> Void)?
|
|
|
|
open override func send(code: UInt8) async throws {
|
|
if let error = sendCodeThrowableError {
|
|
throw error
|
|
}
|
|
sendCodeCallsCountLock.withLock { sendCodeUnderlyingCallsCount += 1 }
|
|
sendCodeReceivedCode = code
|
|
sendCodeReceivedInvocationsLock.withLock { sendCodeUnderlyingReceivedInvocations.append(code) }
|
|
try await sendCodeClosure?(code)
|
|
}
|
|
}
|
|
open class ClientSDKMock: MatrixRustSDK.Client, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
|
|
//MARK: - abortOauthAuth
|
|
|
|
private let abortOauthAuthAuthorizationDataCallsCountLock = NSLock()
|
|
private var abortOauthAuthAuthorizationDataUnderlyingCallsCount = 0
|
|
open var abortOauthAuthAuthorizationDataCallsCount: Int {
|
|
get { abortOauthAuthAuthorizationDataCallsCountLock.withLock { abortOauthAuthAuthorizationDataUnderlyingCallsCount } }
|
|
set { abortOauthAuthAuthorizationDataCallsCountLock.withLock { abortOauthAuthAuthorizationDataUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var abortOauthAuthAuthorizationDataCalled: Bool {
|
|
return abortOauthAuthAuthorizationDataCallsCount > 0
|
|
}
|
|
private let abortOauthAuthAuthorizationDataReceivedAuthorizationDataLock = NSLock()
|
|
private var abortOauthAuthAuthorizationDataUnderlyingReceivedAuthorizationData: OAuthAuthorizationData?
|
|
open var abortOauthAuthAuthorizationDataReceivedAuthorizationData: OAuthAuthorizationData? {
|
|
get { abortOauthAuthAuthorizationDataReceivedAuthorizationDataLock.withLock { abortOauthAuthAuthorizationDataUnderlyingReceivedAuthorizationData } }
|
|
set { abortOauthAuthAuthorizationDataReceivedAuthorizationDataLock.withLock { abortOauthAuthAuthorizationDataUnderlyingReceivedAuthorizationData = newValue } }
|
|
}
|
|
private let abortOauthAuthAuthorizationDataReceivedInvocationsLock = NSLock()
|
|
private var abortOauthAuthAuthorizationDataUnderlyingReceivedInvocations: [OAuthAuthorizationData] = []
|
|
open var abortOauthAuthAuthorizationDataReceivedInvocations: [OAuthAuthorizationData] {
|
|
get { abortOauthAuthAuthorizationDataReceivedInvocationsLock.withLock { abortOauthAuthAuthorizationDataUnderlyingReceivedInvocations } }
|
|
set { abortOauthAuthAuthorizationDataReceivedInvocationsLock.withLock { abortOauthAuthAuthorizationDataUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var abortOauthAuthAuthorizationDataClosure: ((OAuthAuthorizationData) async -> Void)?
|
|
|
|
open override func abortOauthAuth(authorizationData: OAuthAuthorizationData) async {
|
|
abortOauthAuthAuthorizationDataCallsCountLock.withLock { abortOauthAuthAuthorizationDataUnderlyingCallsCount += 1 }
|
|
abortOauthAuthAuthorizationDataReceivedAuthorizationData = authorizationData
|
|
abortOauthAuthAuthorizationDataReceivedInvocationsLock.withLock { abortOauthAuthAuthorizationDataUnderlyingReceivedInvocations.append(authorizationData) }
|
|
await abortOauthAuthAuthorizationDataClosure?(authorizationData)
|
|
}
|
|
|
|
//MARK: - accountData
|
|
|
|
open var accountDataEventTypeThrowableError: Error?
|
|
private let accountDataEventTypeCallsCountLock = NSLock()
|
|
private var accountDataEventTypeUnderlyingCallsCount = 0
|
|
open var accountDataEventTypeCallsCount: Int {
|
|
get { accountDataEventTypeCallsCountLock.withLock { accountDataEventTypeUnderlyingCallsCount } }
|
|
set { accountDataEventTypeCallsCountLock.withLock { accountDataEventTypeUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var accountDataEventTypeCalled: Bool {
|
|
return accountDataEventTypeCallsCount > 0
|
|
}
|
|
private let accountDataEventTypeReceivedEventTypeLock = NSLock()
|
|
private var accountDataEventTypeUnderlyingReceivedEventType: String?
|
|
open var accountDataEventTypeReceivedEventType: String? {
|
|
get { accountDataEventTypeReceivedEventTypeLock.withLock { accountDataEventTypeUnderlyingReceivedEventType } }
|
|
set { accountDataEventTypeReceivedEventTypeLock.withLock { accountDataEventTypeUnderlyingReceivedEventType = newValue } }
|
|
}
|
|
private let accountDataEventTypeReceivedInvocationsLock = NSLock()
|
|
private var accountDataEventTypeUnderlyingReceivedInvocations: [String] = []
|
|
open var accountDataEventTypeReceivedInvocations: [String] {
|
|
get { accountDataEventTypeReceivedInvocationsLock.withLock { accountDataEventTypeUnderlyingReceivedInvocations } }
|
|
set { accountDataEventTypeReceivedInvocationsLock.withLock { accountDataEventTypeUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let accountDataEventTypeReturnValueLock = NSLock()
|
|
open var accountDataEventTypeUnderlyingReturnValue: String?
|
|
open var accountDataEventTypeReturnValue: String? {
|
|
get { accountDataEventTypeReturnValueLock.withLock { accountDataEventTypeUnderlyingReturnValue } }
|
|
set { accountDataEventTypeReturnValueLock.withLock { accountDataEventTypeUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var accountDataEventTypeClosure: ((String) async throws -> String?)?
|
|
|
|
open override func accountData(eventType: String) async throws -> String? {
|
|
if let error = accountDataEventTypeThrowableError {
|
|
throw error
|
|
}
|
|
accountDataEventTypeCallsCountLock.withLock { accountDataEventTypeUnderlyingCallsCount += 1 }
|
|
accountDataEventTypeReceivedEventType = eventType
|
|
accountDataEventTypeReceivedInvocationsLock.withLock { accountDataEventTypeUnderlyingReceivedInvocations.append(eventType) }
|
|
if let accountDataEventTypeClosure = accountDataEventTypeClosure {
|
|
return try await accountDataEventTypeClosure(eventType)
|
|
} else {
|
|
return accountDataEventTypeReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - accountUrl
|
|
|
|
open var accountUrlActionThrowableError: Error?
|
|
private let accountUrlActionCallsCountLock = NSLock()
|
|
private var accountUrlActionUnderlyingCallsCount = 0
|
|
open var accountUrlActionCallsCount: Int {
|
|
get { accountUrlActionCallsCountLock.withLock { accountUrlActionUnderlyingCallsCount } }
|
|
set { accountUrlActionCallsCountLock.withLock { accountUrlActionUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var accountUrlActionCalled: Bool {
|
|
return accountUrlActionCallsCount > 0
|
|
}
|
|
private let accountUrlActionReceivedActionLock = NSLock()
|
|
private var accountUrlActionUnderlyingReceivedAction: AccountManagementAction?
|
|
open var accountUrlActionReceivedAction: AccountManagementAction? {
|
|
get { accountUrlActionReceivedActionLock.withLock { accountUrlActionUnderlyingReceivedAction } }
|
|
set { accountUrlActionReceivedActionLock.withLock { accountUrlActionUnderlyingReceivedAction = newValue } }
|
|
}
|
|
private let accountUrlActionReceivedInvocationsLock = NSLock()
|
|
private var accountUrlActionUnderlyingReceivedInvocations: [AccountManagementAction?] = []
|
|
open var accountUrlActionReceivedInvocations: [AccountManagementAction?] {
|
|
get { accountUrlActionReceivedInvocationsLock.withLock { accountUrlActionUnderlyingReceivedInvocations } }
|
|
set { accountUrlActionReceivedInvocationsLock.withLock { accountUrlActionUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let accountUrlActionReturnValueLock = NSLock()
|
|
open var accountUrlActionUnderlyingReturnValue: String?
|
|
open var accountUrlActionReturnValue: String? {
|
|
get { accountUrlActionReturnValueLock.withLock { accountUrlActionUnderlyingReturnValue } }
|
|
set { accountUrlActionReturnValueLock.withLock { accountUrlActionUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var accountUrlActionClosure: ((AccountManagementAction?) async throws -> String?)?
|
|
|
|
open override func accountUrl(action: AccountManagementAction?) async throws -> String? {
|
|
if let error = accountUrlActionThrowableError {
|
|
throw error
|
|
}
|
|
accountUrlActionCallsCountLock.withLock { accountUrlActionUnderlyingCallsCount += 1 }
|
|
accountUrlActionReceivedAction = action
|
|
accountUrlActionReceivedInvocationsLock.withLock { accountUrlActionUnderlyingReceivedInvocations.append(action) }
|
|
if let accountUrlActionClosure = accountUrlActionClosure {
|
|
return try await accountUrlActionClosure(action)
|
|
} else {
|
|
return accountUrlActionReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - availableSlidingSyncVersions
|
|
|
|
private let availableSlidingSyncVersionsCallsCountLock = NSLock()
|
|
private var availableSlidingSyncVersionsUnderlyingCallsCount = 0
|
|
open var availableSlidingSyncVersionsCallsCount: Int {
|
|
get { availableSlidingSyncVersionsCallsCountLock.withLock { availableSlidingSyncVersionsUnderlyingCallsCount } }
|
|
set { availableSlidingSyncVersionsCallsCountLock.withLock { availableSlidingSyncVersionsUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var availableSlidingSyncVersionsCalled: Bool {
|
|
return availableSlidingSyncVersionsCallsCount > 0
|
|
}
|
|
|
|
private let availableSlidingSyncVersionsReturnValueLock = NSLock()
|
|
open var availableSlidingSyncVersionsUnderlyingReturnValue: [SlidingSyncVersion]!
|
|
open var availableSlidingSyncVersionsReturnValue: [SlidingSyncVersion]! {
|
|
get { availableSlidingSyncVersionsReturnValueLock.withLock { availableSlidingSyncVersionsUnderlyingReturnValue } }
|
|
set { availableSlidingSyncVersionsReturnValueLock.withLock { availableSlidingSyncVersionsUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var availableSlidingSyncVersionsClosure: (() async -> [SlidingSyncVersion])?
|
|
|
|
open override func availableSlidingSyncVersions() async -> [SlidingSyncVersion] {
|
|
availableSlidingSyncVersionsCallsCountLock.withLock { availableSlidingSyncVersionsUnderlyingCallsCount += 1 }
|
|
if let availableSlidingSyncVersionsClosure = availableSlidingSyncVersionsClosure {
|
|
return await availableSlidingSyncVersionsClosure()
|
|
} else {
|
|
return availableSlidingSyncVersionsReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - avatarUrl
|
|
|
|
open var avatarUrlThrowableError: Error?
|
|
private let avatarUrlCallsCountLock = NSLock()
|
|
private var avatarUrlUnderlyingCallsCount = 0
|
|
open var avatarUrlCallsCount: Int {
|
|
get { avatarUrlCallsCountLock.withLock { avatarUrlUnderlyingCallsCount } }
|
|
set { avatarUrlCallsCountLock.withLock { avatarUrlUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var avatarUrlCalled: Bool {
|
|
return avatarUrlCallsCount > 0
|
|
}
|
|
|
|
private let avatarUrlReturnValueLock = NSLock()
|
|
open var avatarUrlUnderlyingReturnValue: String?
|
|
open var avatarUrlReturnValue: String? {
|
|
get { avatarUrlReturnValueLock.withLock { avatarUrlUnderlyingReturnValue } }
|
|
set { avatarUrlReturnValueLock.withLock { avatarUrlUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var avatarUrlClosure: (() async throws -> String?)?
|
|
|
|
open override func avatarUrl() async throws -> String? {
|
|
if let error = avatarUrlThrowableError {
|
|
throw error
|
|
}
|
|
avatarUrlCallsCountLock.withLock { avatarUrlUnderlyingCallsCount += 1 }
|
|
if let avatarUrlClosure = avatarUrlClosure {
|
|
return try await avatarUrlClosure()
|
|
} else {
|
|
return avatarUrlReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - awaitRoomRemoteEcho
|
|
|
|
open var awaitRoomRemoteEchoRoomIdThrowableError: Error?
|
|
private let awaitRoomRemoteEchoRoomIdCallsCountLock = NSLock()
|
|
private var awaitRoomRemoteEchoRoomIdUnderlyingCallsCount = 0
|
|
open var awaitRoomRemoteEchoRoomIdCallsCount: Int {
|
|
get { awaitRoomRemoteEchoRoomIdCallsCountLock.withLock { awaitRoomRemoteEchoRoomIdUnderlyingCallsCount } }
|
|
set { awaitRoomRemoteEchoRoomIdCallsCountLock.withLock { awaitRoomRemoteEchoRoomIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var awaitRoomRemoteEchoRoomIdCalled: Bool {
|
|
return awaitRoomRemoteEchoRoomIdCallsCount > 0
|
|
}
|
|
private let awaitRoomRemoteEchoRoomIdReceivedRoomIdLock = NSLock()
|
|
private var awaitRoomRemoteEchoRoomIdUnderlyingReceivedRoomId: String?
|
|
open var awaitRoomRemoteEchoRoomIdReceivedRoomId: String? {
|
|
get { awaitRoomRemoteEchoRoomIdReceivedRoomIdLock.withLock { awaitRoomRemoteEchoRoomIdUnderlyingReceivedRoomId } }
|
|
set { awaitRoomRemoteEchoRoomIdReceivedRoomIdLock.withLock { awaitRoomRemoteEchoRoomIdUnderlyingReceivedRoomId = newValue } }
|
|
}
|
|
private let awaitRoomRemoteEchoRoomIdReceivedInvocationsLock = NSLock()
|
|
private var awaitRoomRemoteEchoRoomIdUnderlyingReceivedInvocations: [String] = []
|
|
open var awaitRoomRemoteEchoRoomIdReceivedInvocations: [String] {
|
|
get { awaitRoomRemoteEchoRoomIdReceivedInvocationsLock.withLock { awaitRoomRemoteEchoRoomIdUnderlyingReceivedInvocations } }
|
|
set { awaitRoomRemoteEchoRoomIdReceivedInvocationsLock.withLock { awaitRoomRemoteEchoRoomIdUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let awaitRoomRemoteEchoRoomIdReturnValueLock = NSLock()
|
|
open var awaitRoomRemoteEchoRoomIdUnderlyingReturnValue: Room!
|
|
open var awaitRoomRemoteEchoRoomIdReturnValue: Room! {
|
|
get { awaitRoomRemoteEchoRoomIdReturnValueLock.withLock { awaitRoomRemoteEchoRoomIdUnderlyingReturnValue } }
|
|
set { awaitRoomRemoteEchoRoomIdReturnValueLock.withLock { awaitRoomRemoteEchoRoomIdUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var awaitRoomRemoteEchoRoomIdClosure: ((String) async throws -> Room)?
|
|
|
|
open override func awaitRoomRemoteEcho(roomId: String) async throws -> Room {
|
|
if let error = awaitRoomRemoteEchoRoomIdThrowableError {
|
|
throw error
|
|
}
|
|
awaitRoomRemoteEchoRoomIdCallsCountLock.withLock { awaitRoomRemoteEchoRoomIdUnderlyingCallsCount += 1 }
|
|
awaitRoomRemoteEchoRoomIdReceivedRoomId = roomId
|
|
awaitRoomRemoteEchoRoomIdReceivedInvocationsLock.withLock { awaitRoomRemoteEchoRoomIdUnderlyingReceivedInvocations.append(roomId) }
|
|
if let awaitRoomRemoteEchoRoomIdClosure = awaitRoomRemoteEchoRoomIdClosure {
|
|
return try await awaitRoomRemoteEchoRoomIdClosure(roomId)
|
|
} else {
|
|
return awaitRoomRemoteEchoRoomIdReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - cachedAvatarUrl
|
|
|
|
open var cachedAvatarUrlThrowableError: Error?
|
|
private let cachedAvatarUrlCallsCountLock = NSLock()
|
|
private var cachedAvatarUrlUnderlyingCallsCount = 0
|
|
open var cachedAvatarUrlCallsCount: Int {
|
|
get { cachedAvatarUrlCallsCountLock.withLock { cachedAvatarUrlUnderlyingCallsCount } }
|
|
set { cachedAvatarUrlCallsCountLock.withLock { cachedAvatarUrlUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var cachedAvatarUrlCalled: Bool {
|
|
return cachedAvatarUrlCallsCount > 0
|
|
}
|
|
|
|
private let cachedAvatarUrlReturnValueLock = NSLock()
|
|
open var cachedAvatarUrlUnderlyingReturnValue: String?
|
|
open var cachedAvatarUrlReturnValue: String? {
|
|
get { cachedAvatarUrlReturnValueLock.withLock { cachedAvatarUrlUnderlyingReturnValue } }
|
|
set { cachedAvatarUrlReturnValueLock.withLock { cachedAvatarUrlUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var cachedAvatarUrlClosure: (() async throws -> String?)?
|
|
|
|
open override func cachedAvatarUrl() async throws -> String? {
|
|
if let error = cachedAvatarUrlThrowableError {
|
|
throw error
|
|
}
|
|
cachedAvatarUrlCallsCountLock.withLock { cachedAvatarUrlUnderlyingCallsCount += 1 }
|
|
if let cachedAvatarUrlClosure = cachedAvatarUrlClosure {
|
|
return try await cachedAvatarUrlClosure()
|
|
} else {
|
|
return cachedAvatarUrlReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - canDeactivateAccount
|
|
|
|
private let canDeactivateAccountCallsCountLock = NSLock()
|
|
private var canDeactivateAccountUnderlyingCallsCount = 0
|
|
open var canDeactivateAccountCallsCount: Int {
|
|
get { canDeactivateAccountCallsCountLock.withLock { canDeactivateAccountUnderlyingCallsCount } }
|
|
set { canDeactivateAccountCallsCountLock.withLock { canDeactivateAccountUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var canDeactivateAccountCalled: Bool {
|
|
return canDeactivateAccountCallsCount > 0
|
|
}
|
|
|
|
private let canDeactivateAccountReturnValueLock = NSLock()
|
|
open var canDeactivateAccountUnderlyingReturnValue: Bool!
|
|
open var canDeactivateAccountReturnValue: Bool! {
|
|
get { canDeactivateAccountReturnValueLock.withLock { canDeactivateAccountUnderlyingReturnValue } }
|
|
set { canDeactivateAccountReturnValueLock.withLock { canDeactivateAccountUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var canDeactivateAccountClosure: (() -> Bool)?
|
|
|
|
open override func canDeactivateAccount() -> Bool {
|
|
canDeactivateAccountCallsCountLock.withLock { canDeactivateAccountUnderlyingCallsCount += 1 }
|
|
if let canDeactivateAccountClosure = canDeactivateAccountClosure {
|
|
return canDeactivateAccountClosure()
|
|
} else {
|
|
return canDeactivateAccountReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - clearCaches
|
|
|
|
open var clearCachesSyncServiceThrowableError: Error?
|
|
private let clearCachesSyncServiceCallsCountLock = NSLock()
|
|
private var clearCachesSyncServiceUnderlyingCallsCount = 0
|
|
open var clearCachesSyncServiceCallsCount: Int {
|
|
get { clearCachesSyncServiceCallsCountLock.withLock { clearCachesSyncServiceUnderlyingCallsCount } }
|
|
set { clearCachesSyncServiceCallsCountLock.withLock { clearCachesSyncServiceUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var clearCachesSyncServiceCalled: Bool {
|
|
return clearCachesSyncServiceCallsCount > 0
|
|
}
|
|
private let clearCachesSyncServiceReceivedSyncServiceLock = NSLock()
|
|
private var clearCachesSyncServiceUnderlyingReceivedSyncService: SyncService?
|
|
open var clearCachesSyncServiceReceivedSyncService: SyncService? {
|
|
get { clearCachesSyncServiceReceivedSyncServiceLock.withLock { clearCachesSyncServiceUnderlyingReceivedSyncService } }
|
|
set { clearCachesSyncServiceReceivedSyncServiceLock.withLock { clearCachesSyncServiceUnderlyingReceivedSyncService = newValue } }
|
|
}
|
|
private let clearCachesSyncServiceReceivedInvocationsLock = NSLock()
|
|
private var clearCachesSyncServiceUnderlyingReceivedInvocations: [SyncService?] = []
|
|
open var clearCachesSyncServiceReceivedInvocations: [SyncService?] {
|
|
get { clearCachesSyncServiceReceivedInvocationsLock.withLock { clearCachesSyncServiceUnderlyingReceivedInvocations } }
|
|
set { clearCachesSyncServiceReceivedInvocationsLock.withLock { clearCachesSyncServiceUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var clearCachesSyncServiceClosure: ((SyncService?) async throws -> Void)?
|
|
|
|
open override func clearCaches(syncService: SyncService?) async throws {
|
|
if let error = clearCachesSyncServiceThrowableError {
|
|
throw error
|
|
}
|
|
clearCachesSyncServiceCallsCountLock.withLock { clearCachesSyncServiceUnderlyingCallsCount += 1 }
|
|
clearCachesSyncServiceReceivedSyncService = syncService
|
|
clearCachesSyncServiceReceivedInvocationsLock.withLock { clearCachesSyncServiceUnderlyingReceivedInvocations.append(syncService) }
|
|
try await clearCachesSyncServiceClosure?(syncService)
|
|
}
|
|
|
|
//MARK: - contentScanner
|
|
|
|
private let contentScannerCallsCountLock = NSLock()
|
|
private var contentScannerUnderlyingCallsCount = 0
|
|
open var contentScannerCallsCount: Int {
|
|
get { contentScannerCallsCountLock.withLock { contentScannerUnderlyingCallsCount } }
|
|
set { contentScannerCallsCountLock.withLock { contentScannerUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var contentScannerCalled: Bool {
|
|
return contentScannerCallsCount > 0
|
|
}
|
|
|
|
private let contentScannerReturnValueLock = NSLock()
|
|
open var contentScannerUnderlyingReturnValue: ContentScanner?
|
|
open var contentScannerReturnValue: ContentScanner? {
|
|
get { contentScannerReturnValueLock.withLock { contentScannerUnderlyingReturnValue } }
|
|
set { contentScannerReturnValueLock.withLock { contentScannerUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var contentScannerClosure: (() async -> ContentScanner?)?
|
|
|
|
open override func contentScanner() async -> ContentScanner? {
|
|
contentScannerCallsCountLock.withLock { contentScannerUnderlyingCallsCount += 1 }
|
|
if let contentScannerClosure = contentScannerClosure {
|
|
return await contentScannerClosure()
|
|
} else {
|
|
return contentScannerReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - createRoom
|
|
|
|
open var createRoomRequestThrowableError: Error?
|
|
private let createRoomRequestCallsCountLock = NSLock()
|
|
private var createRoomRequestUnderlyingCallsCount = 0
|
|
open var createRoomRequestCallsCount: Int {
|
|
get { createRoomRequestCallsCountLock.withLock { createRoomRequestUnderlyingCallsCount } }
|
|
set { createRoomRequestCallsCountLock.withLock { createRoomRequestUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var createRoomRequestCalled: Bool {
|
|
return createRoomRequestCallsCount > 0
|
|
}
|
|
private let createRoomRequestReceivedRequestLock = NSLock()
|
|
private var createRoomRequestUnderlyingReceivedRequest: CreateRoomParameters?
|
|
open var createRoomRequestReceivedRequest: CreateRoomParameters? {
|
|
get { createRoomRequestReceivedRequestLock.withLock { createRoomRequestUnderlyingReceivedRequest } }
|
|
set { createRoomRequestReceivedRequestLock.withLock { createRoomRequestUnderlyingReceivedRequest = newValue } }
|
|
}
|
|
private let createRoomRequestReceivedInvocationsLock = NSLock()
|
|
private var createRoomRequestUnderlyingReceivedInvocations: [CreateRoomParameters] = []
|
|
open var createRoomRequestReceivedInvocations: [CreateRoomParameters] {
|
|
get { createRoomRequestReceivedInvocationsLock.withLock { createRoomRequestUnderlyingReceivedInvocations } }
|
|
set { createRoomRequestReceivedInvocationsLock.withLock { createRoomRequestUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let createRoomRequestReturnValueLock = NSLock()
|
|
open var createRoomRequestUnderlyingReturnValue: String!
|
|
open var createRoomRequestReturnValue: String! {
|
|
get { createRoomRequestReturnValueLock.withLock { createRoomRequestUnderlyingReturnValue } }
|
|
set { createRoomRequestReturnValueLock.withLock { createRoomRequestUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var createRoomRequestClosure: ((CreateRoomParameters) async throws -> String)?
|
|
|
|
open override func createRoom(request: CreateRoomParameters) async throws -> String {
|
|
if let error = createRoomRequestThrowableError {
|
|
throw error
|
|
}
|
|
createRoomRequestCallsCountLock.withLock { createRoomRequestUnderlyingCallsCount += 1 }
|
|
createRoomRequestReceivedRequest = request
|
|
createRoomRequestReceivedInvocationsLock.withLock { createRoomRequestUnderlyingReceivedInvocations.append(request) }
|
|
if let createRoomRequestClosure = createRoomRequestClosure {
|
|
return try await createRoomRequestClosure(request)
|
|
} else {
|
|
return createRoomRequestReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - customLoginWithJwt
|
|
|
|
open var customLoginWithJwtJwtInitialDeviceNameDeviceIdThrowableError: Error?
|
|
private let customLoginWithJwtJwtInitialDeviceNameDeviceIdCallsCountLock = NSLock()
|
|
private var customLoginWithJwtJwtInitialDeviceNameDeviceIdUnderlyingCallsCount = 0
|
|
open var customLoginWithJwtJwtInitialDeviceNameDeviceIdCallsCount: Int {
|
|
get { customLoginWithJwtJwtInitialDeviceNameDeviceIdCallsCountLock.withLock { customLoginWithJwtJwtInitialDeviceNameDeviceIdUnderlyingCallsCount } }
|
|
set { customLoginWithJwtJwtInitialDeviceNameDeviceIdCallsCountLock.withLock { customLoginWithJwtJwtInitialDeviceNameDeviceIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var customLoginWithJwtJwtInitialDeviceNameDeviceIdCalled: Bool {
|
|
return customLoginWithJwtJwtInitialDeviceNameDeviceIdCallsCount > 0
|
|
}
|
|
private let customLoginWithJwtJwtInitialDeviceNameDeviceIdReceivedArgumentsLock = NSLock()
|
|
private var customLoginWithJwtJwtInitialDeviceNameDeviceIdUnderlyingReceivedArguments: (jwt: String, initialDeviceName: String?, deviceId: String?)?
|
|
open var customLoginWithJwtJwtInitialDeviceNameDeviceIdReceivedArguments: (jwt: String, initialDeviceName: String?, deviceId: String?)? {
|
|
get { customLoginWithJwtJwtInitialDeviceNameDeviceIdReceivedArgumentsLock.withLock { customLoginWithJwtJwtInitialDeviceNameDeviceIdUnderlyingReceivedArguments } }
|
|
set { customLoginWithJwtJwtInitialDeviceNameDeviceIdReceivedArgumentsLock.withLock { customLoginWithJwtJwtInitialDeviceNameDeviceIdUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let customLoginWithJwtJwtInitialDeviceNameDeviceIdReceivedInvocationsLock = NSLock()
|
|
private var customLoginWithJwtJwtInitialDeviceNameDeviceIdUnderlyingReceivedInvocations: [(jwt: String, initialDeviceName: String?, deviceId: String?)] = []
|
|
open var customLoginWithJwtJwtInitialDeviceNameDeviceIdReceivedInvocations: [(jwt: String, initialDeviceName: String?, deviceId: String?)] {
|
|
get { customLoginWithJwtJwtInitialDeviceNameDeviceIdReceivedInvocationsLock.withLock { customLoginWithJwtJwtInitialDeviceNameDeviceIdUnderlyingReceivedInvocations } }
|
|
set { customLoginWithJwtJwtInitialDeviceNameDeviceIdReceivedInvocationsLock.withLock { customLoginWithJwtJwtInitialDeviceNameDeviceIdUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var customLoginWithJwtJwtInitialDeviceNameDeviceIdClosure: ((String, String?, String?) async throws -> Void)?
|
|
|
|
open override func customLoginWithJwt(jwt: String, initialDeviceName: String?, deviceId: String?) async throws {
|
|
if let error = customLoginWithJwtJwtInitialDeviceNameDeviceIdThrowableError {
|
|
throw error
|
|
}
|
|
customLoginWithJwtJwtInitialDeviceNameDeviceIdCallsCountLock.withLock { customLoginWithJwtJwtInitialDeviceNameDeviceIdUnderlyingCallsCount += 1 }
|
|
customLoginWithJwtJwtInitialDeviceNameDeviceIdReceivedArguments = (jwt: jwt, initialDeviceName: initialDeviceName, deviceId: deviceId)
|
|
customLoginWithJwtJwtInitialDeviceNameDeviceIdReceivedInvocationsLock.withLock { customLoginWithJwtJwtInitialDeviceNameDeviceIdUnderlyingReceivedInvocations.append((jwt: jwt, initialDeviceName: initialDeviceName, deviceId: deviceId)) }
|
|
try await customLoginWithJwtJwtInitialDeviceNameDeviceIdClosure?(jwt, initialDeviceName, deviceId)
|
|
}
|
|
|
|
//MARK: - deactivateAccount
|
|
|
|
open var deactivateAccountAuthDataEraseDataThrowableError: Error?
|
|
private let deactivateAccountAuthDataEraseDataCallsCountLock = NSLock()
|
|
private var deactivateAccountAuthDataEraseDataUnderlyingCallsCount = 0
|
|
open var deactivateAccountAuthDataEraseDataCallsCount: Int {
|
|
get { deactivateAccountAuthDataEraseDataCallsCountLock.withLock { deactivateAccountAuthDataEraseDataUnderlyingCallsCount } }
|
|
set { deactivateAccountAuthDataEraseDataCallsCountLock.withLock { deactivateAccountAuthDataEraseDataUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var deactivateAccountAuthDataEraseDataCalled: Bool {
|
|
return deactivateAccountAuthDataEraseDataCallsCount > 0
|
|
}
|
|
private let deactivateAccountAuthDataEraseDataReceivedArgumentsLock = NSLock()
|
|
private var deactivateAccountAuthDataEraseDataUnderlyingReceivedArguments: (authData: AuthData?, eraseData: Bool)?
|
|
open var deactivateAccountAuthDataEraseDataReceivedArguments: (authData: AuthData?, eraseData: Bool)? {
|
|
get { deactivateAccountAuthDataEraseDataReceivedArgumentsLock.withLock { deactivateAccountAuthDataEraseDataUnderlyingReceivedArguments } }
|
|
set { deactivateAccountAuthDataEraseDataReceivedArgumentsLock.withLock { deactivateAccountAuthDataEraseDataUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let deactivateAccountAuthDataEraseDataReceivedInvocationsLock = NSLock()
|
|
private var deactivateAccountAuthDataEraseDataUnderlyingReceivedInvocations: [(authData: AuthData?, eraseData: Bool)] = []
|
|
open var deactivateAccountAuthDataEraseDataReceivedInvocations: [(authData: AuthData?, eraseData: Bool)] {
|
|
get { deactivateAccountAuthDataEraseDataReceivedInvocationsLock.withLock { deactivateAccountAuthDataEraseDataUnderlyingReceivedInvocations } }
|
|
set { deactivateAccountAuthDataEraseDataReceivedInvocationsLock.withLock { deactivateAccountAuthDataEraseDataUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var deactivateAccountAuthDataEraseDataClosure: ((AuthData?, Bool) async throws -> Void)?
|
|
|
|
open override func deactivateAccount(authData: AuthData?, eraseData: Bool) async throws {
|
|
if let error = deactivateAccountAuthDataEraseDataThrowableError {
|
|
throw error
|
|
}
|
|
deactivateAccountAuthDataEraseDataCallsCountLock.withLock { deactivateAccountAuthDataEraseDataUnderlyingCallsCount += 1 }
|
|
deactivateAccountAuthDataEraseDataReceivedArguments = (authData: authData, eraseData: eraseData)
|
|
deactivateAccountAuthDataEraseDataReceivedInvocationsLock.withLock { deactivateAccountAuthDataEraseDataUnderlyingReceivedInvocations.append((authData: authData, eraseData: eraseData)) }
|
|
try await deactivateAccountAuthDataEraseDataClosure?(authData, eraseData)
|
|
}
|
|
|
|
//MARK: - deletePusher
|
|
|
|
open var deletePusherIdentifiersThrowableError: Error?
|
|
private let deletePusherIdentifiersCallsCountLock = NSLock()
|
|
private var deletePusherIdentifiersUnderlyingCallsCount = 0
|
|
open var deletePusherIdentifiersCallsCount: Int {
|
|
get { deletePusherIdentifiersCallsCountLock.withLock { deletePusherIdentifiersUnderlyingCallsCount } }
|
|
set { deletePusherIdentifiersCallsCountLock.withLock { deletePusherIdentifiersUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var deletePusherIdentifiersCalled: Bool {
|
|
return deletePusherIdentifiersCallsCount > 0
|
|
}
|
|
private let deletePusherIdentifiersReceivedIdentifiersLock = NSLock()
|
|
private var deletePusherIdentifiersUnderlyingReceivedIdentifiers: PusherIdentifiers?
|
|
open var deletePusherIdentifiersReceivedIdentifiers: PusherIdentifiers? {
|
|
get { deletePusherIdentifiersReceivedIdentifiersLock.withLock { deletePusherIdentifiersUnderlyingReceivedIdentifiers } }
|
|
set { deletePusherIdentifiersReceivedIdentifiersLock.withLock { deletePusherIdentifiersUnderlyingReceivedIdentifiers = newValue } }
|
|
}
|
|
private let deletePusherIdentifiersReceivedInvocationsLock = NSLock()
|
|
private var deletePusherIdentifiersUnderlyingReceivedInvocations: [PusherIdentifiers] = []
|
|
open var deletePusherIdentifiersReceivedInvocations: [PusherIdentifiers] {
|
|
get { deletePusherIdentifiersReceivedInvocationsLock.withLock { deletePusherIdentifiersUnderlyingReceivedInvocations } }
|
|
set { deletePusherIdentifiersReceivedInvocationsLock.withLock { deletePusherIdentifiersUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var deletePusherIdentifiersClosure: ((PusherIdentifiers) async throws -> Void)?
|
|
|
|
open override func deletePusher(identifiers: PusherIdentifiers) async throws {
|
|
if let error = deletePusherIdentifiersThrowableError {
|
|
throw error
|
|
}
|
|
deletePusherIdentifiersCallsCountLock.withLock { deletePusherIdentifiersUnderlyingCallsCount += 1 }
|
|
deletePusherIdentifiersReceivedIdentifiers = identifiers
|
|
deletePusherIdentifiersReceivedInvocationsLock.withLock { deletePusherIdentifiersUnderlyingReceivedInvocations.append(identifiers) }
|
|
try await deletePusherIdentifiersClosure?(identifiers)
|
|
}
|
|
|
|
//MARK: - deviceId
|
|
|
|
open var deviceIdThrowableError: Error?
|
|
private let deviceIdCallsCountLock = NSLock()
|
|
private var deviceIdUnderlyingCallsCount = 0
|
|
open var deviceIdCallsCount: Int {
|
|
get { deviceIdCallsCountLock.withLock { deviceIdUnderlyingCallsCount } }
|
|
set { deviceIdCallsCountLock.withLock { deviceIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var deviceIdCalled: Bool {
|
|
return deviceIdCallsCount > 0
|
|
}
|
|
|
|
private let deviceIdReturnValueLock = NSLock()
|
|
open var deviceIdUnderlyingReturnValue: String!
|
|
open var deviceIdReturnValue: String! {
|
|
get { deviceIdReturnValueLock.withLock { deviceIdUnderlyingReturnValue } }
|
|
set { deviceIdReturnValueLock.withLock { deviceIdUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var deviceIdClosure: (() throws -> String)?
|
|
|
|
open override func deviceId() throws -> String {
|
|
if let error = deviceIdThrowableError {
|
|
throw error
|
|
}
|
|
deviceIdCallsCountLock.withLock { deviceIdUnderlyingCallsCount += 1 }
|
|
if let deviceIdClosure = deviceIdClosure {
|
|
return try deviceIdClosure()
|
|
} else {
|
|
return deviceIdReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - displayName
|
|
|
|
open var displayNameThrowableError: Error?
|
|
private let displayNameCallsCountLock = NSLock()
|
|
private var displayNameUnderlyingCallsCount = 0
|
|
open var displayNameCallsCount: Int {
|
|
get { displayNameCallsCountLock.withLock { displayNameUnderlyingCallsCount } }
|
|
set { displayNameCallsCountLock.withLock { displayNameUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var displayNameCalled: Bool {
|
|
return displayNameCallsCount > 0
|
|
}
|
|
|
|
private let displayNameReturnValueLock = NSLock()
|
|
open var displayNameUnderlyingReturnValue: String!
|
|
open var displayNameReturnValue: String! {
|
|
get { displayNameReturnValueLock.withLock { displayNameUnderlyingReturnValue } }
|
|
set { displayNameReturnValueLock.withLock { displayNameUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var displayNameClosure: (() async throws -> String)?
|
|
|
|
open override func displayName() async throws -> String {
|
|
if let error = displayNameThrowableError {
|
|
throw error
|
|
}
|
|
displayNameCallsCountLock.withLock { displayNameUnderlyingCallsCount += 1 }
|
|
if let displayNameClosure = displayNameClosure {
|
|
return try await displayNameClosure()
|
|
} else {
|
|
return displayNameReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - enableAllSendQueues
|
|
|
|
private let enableAllSendQueuesEnableCallsCountLock = NSLock()
|
|
private var enableAllSendQueuesEnableUnderlyingCallsCount = 0
|
|
open var enableAllSendQueuesEnableCallsCount: Int {
|
|
get { enableAllSendQueuesEnableCallsCountLock.withLock { enableAllSendQueuesEnableUnderlyingCallsCount } }
|
|
set { enableAllSendQueuesEnableCallsCountLock.withLock { enableAllSendQueuesEnableUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var enableAllSendQueuesEnableCalled: Bool {
|
|
return enableAllSendQueuesEnableCallsCount > 0
|
|
}
|
|
private let enableAllSendQueuesEnableReceivedEnableLock = NSLock()
|
|
private var enableAllSendQueuesEnableUnderlyingReceivedEnable: Bool?
|
|
open var enableAllSendQueuesEnableReceivedEnable: Bool? {
|
|
get { enableAllSendQueuesEnableReceivedEnableLock.withLock { enableAllSendQueuesEnableUnderlyingReceivedEnable } }
|
|
set { enableAllSendQueuesEnableReceivedEnableLock.withLock { enableAllSendQueuesEnableUnderlyingReceivedEnable = newValue } }
|
|
}
|
|
private let enableAllSendQueuesEnableReceivedInvocationsLock = NSLock()
|
|
private var enableAllSendQueuesEnableUnderlyingReceivedInvocations: [Bool] = []
|
|
open var enableAllSendQueuesEnableReceivedInvocations: [Bool] {
|
|
get { enableAllSendQueuesEnableReceivedInvocationsLock.withLock { enableAllSendQueuesEnableUnderlyingReceivedInvocations } }
|
|
set { enableAllSendQueuesEnableReceivedInvocationsLock.withLock { enableAllSendQueuesEnableUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var enableAllSendQueuesEnableClosure: ((Bool) async -> Void)?
|
|
|
|
open override func enableAllSendQueues(enable: Bool) async {
|
|
enableAllSendQueuesEnableCallsCountLock.withLock { enableAllSendQueuesEnableUnderlyingCallsCount += 1 }
|
|
enableAllSendQueuesEnableReceivedEnable = enable
|
|
enableAllSendQueuesEnableReceivedInvocationsLock.withLock { enableAllSendQueuesEnableUnderlyingReceivedInvocations.append(enable) }
|
|
await enableAllSendQueuesEnableClosure?(enable)
|
|
}
|
|
|
|
//MARK: - enableAutomaticBackpagination
|
|
|
|
private let enableAutomaticBackpaginationCallsCountLock = NSLock()
|
|
private var enableAutomaticBackpaginationUnderlyingCallsCount = 0
|
|
open var enableAutomaticBackpaginationCallsCount: Int {
|
|
get { enableAutomaticBackpaginationCallsCountLock.withLock { enableAutomaticBackpaginationUnderlyingCallsCount } }
|
|
set { enableAutomaticBackpaginationCallsCountLock.withLock { enableAutomaticBackpaginationUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var enableAutomaticBackpaginationCalled: Bool {
|
|
return enableAutomaticBackpaginationCallsCount > 0
|
|
}
|
|
open var enableAutomaticBackpaginationClosure: (() -> Void)?
|
|
|
|
open override func enableAutomaticBackpagination() {
|
|
enableAutomaticBackpaginationCallsCountLock.withLock { enableAutomaticBackpaginationUnderlyingCallsCount += 1 }
|
|
enableAutomaticBackpaginationClosure?()
|
|
}
|
|
|
|
//MARK: - enableSendQueueUploadProgress
|
|
|
|
private let enableSendQueueUploadProgressEnableCallsCountLock = NSLock()
|
|
private var enableSendQueueUploadProgressEnableUnderlyingCallsCount = 0
|
|
open var enableSendQueueUploadProgressEnableCallsCount: Int {
|
|
get { enableSendQueueUploadProgressEnableCallsCountLock.withLock { enableSendQueueUploadProgressEnableUnderlyingCallsCount } }
|
|
set { enableSendQueueUploadProgressEnableCallsCountLock.withLock { enableSendQueueUploadProgressEnableUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var enableSendQueueUploadProgressEnableCalled: Bool {
|
|
return enableSendQueueUploadProgressEnableCallsCount > 0
|
|
}
|
|
private let enableSendQueueUploadProgressEnableReceivedEnableLock = NSLock()
|
|
private var enableSendQueueUploadProgressEnableUnderlyingReceivedEnable: Bool?
|
|
open var enableSendQueueUploadProgressEnableReceivedEnable: Bool? {
|
|
get { enableSendQueueUploadProgressEnableReceivedEnableLock.withLock { enableSendQueueUploadProgressEnableUnderlyingReceivedEnable } }
|
|
set { enableSendQueueUploadProgressEnableReceivedEnableLock.withLock { enableSendQueueUploadProgressEnableUnderlyingReceivedEnable = newValue } }
|
|
}
|
|
private let enableSendQueueUploadProgressEnableReceivedInvocationsLock = NSLock()
|
|
private var enableSendQueueUploadProgressEnableUnderlyingReceivedInvocations: [Bool] = []
|
|
open var enableSendQueueUploadProgressEnableReceivedInvocations: [Bool] {
|
|
get { enableSendQueueUploadProgressEnableReceivedInvocationsLock.withLock { enableSendQueueUploadProgressEnableUnderlyingReceivedInvocations } }
|
|
set { enableSendQueueUploadProgressEnableReceivedInvocationsLock.withLock { enableSendQueueUploadProgressEnableUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var enableSendQueueUploadProgressEnableClosure: ((Bool) -> Void)?
|
|
|
|
open override func enableSendQueueUploadProgress(enable: Bool) {
|
|
enableSendQueueUploadProgressEnableCallsCountLock.withLock { enableSendQueueUploadProgressEnableUnderlyingCallsCount += 1 }
|
|
enableSendQueueUploadProgressEnableReceivedEnable = enable
|
|
enableSendQueueUploadProgressEnableReceivedInvocationsLock.withLock { enableSendQueueUploadProgressEnableUnderlyingReceivedInvocations.append(enable) }
|
|
enableSendQueueUploadProgressEnableClosure?(enable)
|
|
}
|
|
|
|
//MARK: - encryption
|
|
|
|
private let encryptionCallsCountLock = NSLock()
|
|
private var encryptionUnderlyingCallsCount = 0
|
|
open var encryptionCallsCount: Int {
|
|
get { encryptionCallsCountLock.withLock { encryptionUnderlyingCallsCount } }
|
|
set { encryptionCallsCountLock.withLock { encryptionUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var encryptionCalled: Bool {
|
|
return encryptionCallsCount > 0
|
|
}
|
|
|
|
private let encryptionReturnValueLock = NSLock()
|
|
open var encryptionUnderlyingReturnValue: Encryption!
|
|
open var encryptionReturnValue: Encryption! {
|
|
get { encryptionReturnValueLock.withLock { encryptionUnderlyingReturnValue } }
|
|
set { encryptionReturnValueLock.withLock { encryptionUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var encryptionClosure: (() -> Encryption)?
|
|
|
|
open override func encryption() -> Encryption {
|
|
encryptionCallsCountLock.withLock { encryptionUnderlyingCallsCount += 1 }
|
|
if let encryptionClosure = encryptionClosure {
|
|
return encryptionClosure()
|
|
} else {
|
|
return encryptionReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - fetchMediaPreviewConfig
|
|
|
|
open var fetchMediaPreviewConfigThrowableError: Error?
|
|
private let fetchMediaPreviewConfigCallsCountLock = NSLock()
|
|
private var fetchMediaPreviewConfigUnderlyingCallsCount = 0
|
|
open var fetchMediaPreviewConfigCallsCount: Int {
|
|
get { fetchMediaPreviewConfigCallsCountLock.withLock { fetchMediaPreviewConfigUnderlyingCallsCount } }
|
|
set { fetchMediaPreviewConfigCallsCountLock.withLock { fetchMediaPreviewConfigUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var fetchMediaPreviewConfigCalled: Bool {
|
|
return fetchMediaPreviewConfigCallsCount > 0
|
|
}
|
|
|
|
private let fetchMediaPreviewConfigReturnValueLock = NSLock()
|
|
open var fetchMediaPreviewConfigUnderlyingReturnValue: MediaPreviewConfig?
|
|
open var fetchMediaPreviewConfigReturnValue: MediaPreviewConfig? {
|
|
get { fetchMediaPreviewConfigReturnValueLock.withLock { fetchMediaPreviewConfigUnderlyingReturnValue } }
|
|
set { fetchMediaPreviewConfigReturnValueLock.withLock { fetchMediaPreviewConfigUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var fetchMediaPreviewConfigClosure: (() async throws -> MediaPreviewConfig?)?
|
|
|
|
open override func fetchMediaPreviewConfig() async throws -> MediaPreviewConfig? {
|
|
if let error = fetchMediaPreviewConfigThrowableError {
|
|
throw error
|
|
}
|
|
fetchMediaPreviewConfigCallsCountLock.withLock { fetchMediaPreviewConfigUnderlyingCallsCount += 1 }
|
|
if let fetchMediaPreviewConfigClosure = fetchMediaPreviewConfigClosure {
|
|
return try await fetchMediaPreviewConfigClosure()
|
|
} else {
|
|
return fetchMediaPreviewConfigReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - getDmRoom
|
|
|
|
open var getDmRoomUserIdThrowableError: Error?
|
|
private let getDmRoomUserIdCallsCountLock = NSLock()
|
|
private var getDmRoomUserIdUnderlyingCallsCount = 0
|
|
open var getDmRoomUserIdCallsCount: Int {
|
|
get { getDmRoomUserIdCallsCountLock.withLock { getDmRoomUserIdUnderlyingCallsCount } }
|
|
set { getDmRoomUserIdCallsCountLock.withLock { getDmRoomUserIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var getDmRoomUserIdCalled: Bool {
|
|
return getDmRoomUserIdCallsCount > 0
|
|
}
|
|
private let getDmRoomUserIdReceivedUserIdLock = NSLock()
|
|
private var getDmRoomUserIdUnderlyingReceivedUserId: String?
|
|
open var getDmRoomUserIdReceivedUserId: String? {
|
|
get { getDmRoomUserIdReceivedUserIdLock.withLock { getDmRoomUserIdUnderlyingReceivedUserId } }
|
|
set { getDmRoomUserIdReceivedUserIdLock.withLock { getDmRoomUserIdUnderlyingReceivedUserId = newValue } }
|
|
}
|
|
private let getDmRoomUserIdReceivedInvocationsLock = NSLock()
|
|
private var getDmRoomUserIdUnderlyingReceivedInvocations: [String] = []
|
|
open var getDmRoomUserIdReceivedInvocations: [String] {
|
|
get { getDmRoomUserIdReceivedInvocationsLock.withLock { getDmRoomUserIdUnderlyingReceivedInvocations } }
|
|
set { getDmRoomUserIdReceivedInvocationsLock.withLock { getDmRoomUserIdUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let getDmRoomUserIdReturnValueLock = NSLock()
|
|
open var getDmRoomUserIdUnderlyingReturnValue: Room?
|
|
open var getDmRoomUserIdReturnValue: Room? {
|
|
get { getDmRoomUserIdReturnValueLock.withLock { getDmRoomUserIdUnderlyingReturnValue } }
|
|
set { getDmRoomUserIdReturnValueLock.withLock { getDmRoomUserIdUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var getDmRoomUserIdClosure: ((String) throws -> Room?)?
|
|
|
|
open override func getDmRoom(userId: String) throws -> Room? {
|
|
if let error = getDmRoomUserIdThrowableError {
|
|
throw error
|
|
}
|
|
getDmRoomUserIdCallsCountLock.withLock { getDmRoomUserIdUnderlyingCallsCount += 1 }
|
|
getDmRoomUserIdReceivedUserId = userId
|
|
getDmRoomUserIdReceivedInvocationsLock.withLock { getDmRoomUserIdUnderlyingReceivedInvocations.append(userId) }
|
|
if let getDmRoomUserIdClosure = getDmRoomUserIdClosure {
|
|
return try getDmRoomUserIdClosure(userId)
|
|
} else {
|
|
return getDmRoomUserIdReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - getDmRooms
|
|
|
|
open var getDmRoomsUserIdThrowableError: Error?
|
|
private let getDmRoomsUserIdCallsCountLock = NSLock()
|
|
private var getDmRoomsUserIdUnderlyingCallsCount = 0
|
|
open var getDmRoomsUserIdCallsCount: Int {
|
|
get { getDmRoomsUserIdCallsCountLock.withLock { getDmRoomsUserIdUnderlyingCallsCount } }
|
|
set { getDmRoomsUserIdCallsCountLock.withLock { getDmRoomsUserIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var getDmRoomsUserIdCalled: Bool {
|
|
return getDmRoomsUserIdCallsCount > 0
|
|
}
|
|
private let getDmRoomsUserIdReceivedUserIdLock = NSLock()
|
|
private var getDmRoomsUserIdUnderlyingReceivedUserId: String?
|
|
open var getDmRoomsUserIdReceivedUserId: String? {
|
|
get { getDmRoomsUserIdReceivedUserIdLock.withLock { getDmRoomsUserIdUnderlyingReceivedUserId } }
|
|
set { getDmRoomsUserIdReceivedUserIdLock.withLock { getDmRoomsUserIdUnderlyingReceivedUserId = newValue } }
|
|
}
|
|
private let getDmRoomsUserIdReceivedInvocationsLock = NSLock()
|
|
private var getDmRoomsUserIdUnderlyingReceivedInvocations: [String] = []
|
|
open var getDmRoomsUserIdReceivedInvocations: [String] {
|
|
get { getDmRoomsUserIdReceivedInvocationsLock.withLock { getDmRoomsUserIdUnderlyingReceivedInvocations } }
|
|
set { getDmRoomsUserIdReceivedInvocationsLock.withLock { getDmRoomsUserIdUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let getDmRoomsUserIdReturnValueLock = NSLock()
|
|
open var getDmRoomsUserIdUnderlyingReturnValue: [Room]!
|
|
open var getDmRoomsUserIdReturnValue: [Room]! {
|
|
get { getDmRoomsUserIdReturnValueLock.withLock { getDmRoomsUserIdUnderlyingReturnValue } }
|
|
set { getDmRoomsUserIdReturnValueLock.withLock { getDmRoomsUserIdUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var getDmRoomsUserIdClosure: ((String) throws -> [Room])?
|
|
|
|
open override func getDmRooms(userId: String) throws -> [Room] {
|
|
if let error = getDmRoomsUserIdThrowableError {
|
|
throw error
|
|
}
|
|
getDmRoomsUserIdCallsCountLock.withLock { getDmRoomsUserIdUnderlyingCallsCount += 1 }
|
|
getDmRoomsUserIdReceivedUserId = userId
|
|
getDmRoomsUserIdReceivedInvocationsLock.withLock { getDmRoomsUserIdUnderlyingReceivedInvocations.append(userId) }
|
|
if let getDmRoomsUserIdClosure = getDmRoomsUserIdClosure {
|
|
return try getDmRoomsUserIdClosure(userId)
|
|
} else {
|
|
return getDmRoomsUserIdReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - getInviteAvatarsDisplayPolicy
|
|
|
|
open var getInviteAvatarsDisplayPolicyThrowableError: Error?
|
|
private let getInviteAvatarsDisplayPolicyCallsCountLock = NSLock()
|
|
private var getInviteAvatarsDisplayPolicyUnderlyingCallsCount = 0
|
|
open var getInviteAvatarsDisplayPolicyCallsCount: Int {
|
|
get { getInviteAvatarsDisplayPolicyCallsCountLock.withLock { getInviteAvatarsDisplayPolicyUnderlyingCallsCount } }
|
|
set { getInviteAvatarsDisplayPolicyCallsCountLock.withLock { getInviteAvatarsDisplayPolicyUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var getInviteAvatarsDisplayPolicyCalled: Bool {
|
|
return getInviteAvatarsDisplayPolicyCallsCount > 0
|
|
}
|
|
|
|
private let getInviteAvatarsDisplayPolicyReturnValueLock = NSLock()
|
|
open var getInviteAvatarsDisplayPolicyUnderlyingReturnValue: InviteAvatars?
|
|
open var getInviteAvatarsDisplayPolicyReturnValue: InviteAvatars? {
|
|
get { getInviteAvatarsDisplayPolicyReturnValueLock.withLock { getInviteAvatarsDisplayPolicyUnderlyingReturnValue } }
|
|
set { getInviteAvatarsDisplayPolicyReturnValueLock.withLock { getInviteAvatarsDisplayPolicyUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var getInviteAvatarsDisplayPolicyClosure: (() async throws -> InviteAvatars?)?
|
|
|
|
open override func getInviteAvatarsDisplayPolicy() async throws -> InviteAvatars? {
|
|
if let error = getInviteAvatarsDisplayPolicyThrowableError {
|
|
throw error
|
|
}
|
|
getInviteAvatarsDisplayPolicyCallsCountLock.withLock { getInviteAvatarsDisplayPolicyUnderlyingCallsCount += 1 }
|
|
if let getInviteAvatarsDisplayPolicyClosure = getInviteAvatarsDisplayPolicyClosure {
|
|
return try await getInviteAvatarsDisplayPolicyClosure()
|
|
} else {
|
|
return getInviteAvatarsDisplayPolicyReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - getMaxMediaUploadSize
|
|
|
|
open var getMaxMediaUploadSizeThrowableError: Error?
|
|
private let getMaxMediaUploadSizeCallsCountLock = NSLock()
|
|
private var getMaxMediaUploadSizeUnderlyingCallsCount = 0
|
|
open var getMaxMediaUploadSizeCallsCount: Int {
|
|
get { getMaxMediaUploadSizeCallsCountLock.withLock { getMaxMediaUploadSizeUnderlyingCallsCount } }
|
|
set { getMaxMediaUploadSizeCallsCountLock.withLock { getMaxMediaUploadSizeUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var getMaxMediaUploadSizeCalled: Bool {
|
|
return getMaxMediaUploadSizeCallsCount > 0
|
|
}
|
|
|
|
private let getMaxMediaUploadSizeReturnValueLock = NSLock()
|
|
open var getMaxMediaUploadSizeUnderlyingReturnValue: UInt64!
|
|
open var getMaxMediaUploadSizeReturnValue: UInt64! {
|
|
get { getMaxMediaUploadSizeReturnValueLock.withLock { getMaxMediaUploadSizeUnderlyingReturnValue } }
|
|
set { getMaxMediaUploadSizeReturnValueLock.withLock { getMaxMediaUploadSizeUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var getMaxMediaUploadSizeClosure: (() async throws -> UInt64)?
|
|
|
|
open override func getMaxMediaUploadSize() async throws -> UInt64 {
|
|
if let error = getMaxMediaUploadSizeThrowableError {
|
|
throw error
|
|
}
|
|
getMaxMediaUploadSizeCallsCountLock.withLock { getMaxMediaUploadSizeUnderlyingCallsCount += 1 }
|
|
if let getMaxMediaUploadSizeClosure = getMaxMediaUploadSizeClosure {
|
|
return try await getMaxMediaUploadSizeClosure()
|
|
} else {
|
|
return getMaxMediaUploadSizeReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - getMediaContent
|
|
|
|
open var getMediaContentMediaSourceThrowableError: Error?
|
|
private let getMediaContentMediaSourceCallsCountLock = NSLock()
|
|
private var getMediaContentMediaSourceUnderlyingCallsCount = 0
|
|
open var getMediaContentMediaSourceCallsCount: Int {
|
|
get { getMediaContentMediaSourceCallsCountLock.withLock { getMediaContentMediaSourceUnderlyingCallsCount } }
|
|
set { getMediaContentMediaSourceCallsCountLock.withLock { getMediaContentMediaSourceUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var getMediaContentMediaSourceCalled: Bool {
|
|
return getMediaContentMediaSourceCallsCount > 0
|
|
}
|
|
private let getMediaContentMediaSourceReceivedMediaSourceLock = NSLock()
|
|
private var getMediaContentMediaSourceUnderlyingReceivedMediaSource: MediaSource?
|
|
open var getMediaContentMediaSourceReceivedMediaSource: MediaSource? {
|
|
get { getMediaContentMediaSourceReceivedMediaSourceLock.withLock { getMediaContentMediaSourceUnderlyingReceivedMediaSource } }
|
|
set { getMediaContentMediaSourceReceivedMediaSourceLock.withLock { getMediaContentMediaSourceUnderlyingReceivedMediaSource = newValue } }
|
|
}
|
|
private let getMediaContentMediaSourceReceivedInvocationsLock = NSLock()
|
|
private var getMediaContentMediaSourceUnderlyingReceivedInvocations: [MediaSource] = []
|
|
open var getMediaContentMediaSourceReceivedInvocations: [MediaSource] {
|
|
get { getMediaContentMediaSourceReceivedInvocationsLock.withLock { getMediaContentMediaSourceUnderlyingReceivedInvocations } }
|
|
set { getMediaContentMediaSourceReceivedInvocationsLock.withLock { getMediaContentMediaSourceUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let getMediaContentMediaSourceReturnValueLock = NSLock()
|
|
open var getMediaContentMediaSourceUnderlyingReturnValue: Data!
|
|
open var getMediaContentMediaSourceReturnValue: Data! {
|
|
get { getMediaContentMediaSourceReturnValueLock.withLock { getMediaContentMediaSourceUnderlyingReturnValue } }
|
|
set { getMediaContentMediaSourceReturnValueLock.withLock { getMediaContentMediaSourceUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var getMediaContentMediaSourceClosure: ((MediaSource) async throws -> Data)?
|
|
|
|
open override func getMediaContent(mediaSource: MediaSource) async throws -> Data {
|
|
if let error = getMediaContentMediaSourceThrowableError {
|
|
throw error
|
|
}
|
|
getMediaContentMediaSourceCallsCountLock.withLock { getMediaContentMediaSourceUnderlyingCallsCount += 1 }
|
|
getMediaContentMediaSourceReceivedMediaSource = mediaSource
|
|
getMediaContentMediaSourceReceivedInvocationsLock.withLock { getMediaContentMediaSourceUnderlyingReceivedInvocations.append(mediaSource) }
|
|
if let getMediaContentMediaSourceClosure = getMediaContentMediaSourceClosure {
|
|
return try await getMediaContentMediaSourceClosure(mediaSource)
|
|
} else {
|
|
return getMediaContentMediaSourceReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - getMediaFile
|
|
|
|
open var getMediaFileMediaSourceFilenameMimeTypeUseCacheTempDirThrowableError: Error?
|
|
private let getMediaFileMediaSourceFilenameMimeTypeUseCacheTempDirCallsCountLock = NSLock()
|
|
private var getMediaFileMediaSourceFilenameMimeTypeUseCacheTempDirUnderlyingCallsCount = 0
|
|
open var getMediaFileMediaSourceFilenameMimeTypeUseCacheTempDirCallsCount: Int {
|
|
get { getMediaFileMediaSourceFilenameMimeTypeUseCacheTempDirCallsCountLock.withLock { getMediaFileMediaSourceFilenameMimeTypeUseCacheTempDirUnderlyingCallsCount } }
|
|
set { getMediaFileMediaSourceFilenameMimeTypeUseCacheTempDirCallsCountLock.withLock { getMediaFileMediaSourceFilenameMimeTypeUseCacheTempDirUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var getMediaFileMediaSourceFilenameMimeTypeUseCacheTempDirCalled: Bool {
|
|
return getMediaFileMediaSourceFilenameMimeTypeUseCacheTempDirCallsCount > 0
|
|
}
|
|
private let getMediaFileMediaSourceFilenameMimeTypeUseCacheTempDirReceivedArgumentsLock = NSLock()
|
|
private var getMediaFileMediaSourceFilenameMimeTypeUseCacheTempDirUnderlyingReceivedArguments: (mediaSource: MediaSource, filename: String?, mimeType: String, useCache: Bool, tempDir: String?)?
|
|
open var getMediaFileMediaSourceFilenameMimeTypeUseCacheTempDirReceivedArguments: (mediaSource: MediaSource, filename: String?, mimeType: String, useCache: Bool, tempDir: String?)? {
|
|
get { getMediaFileMediaSourceFilenameMimeTypeUseCacheTempDirReceivedArgumentsLock.withLock { getMediaFileMediaSourceFilenameMimeTypeUseCacheTempDirUnderlyingReceivedArguments } }
|
|
set { getMediaFileMediaSourceFilenameMimeTypeUseCacheTempDirReceivedArgumentsLock.withLock { getMediaFileMediaSourceFilenameMimeTypeUseCacheTempDirUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let getMediaFileMediaSourceFilenameMimeTypeUseCacheTempDirReceivedInvocationsLock = NSLock()
|
|
private var getMediaFileMediaSourceFilenameMimeTypeUseCacheTempDirUnderlyingReceivedInvocations: [(mediaSource: MediaSource, filename: String?, mimeType: String, useCache: Bool, tempDir: String?)] = []
|
|
open var getMediaFileMediaSourceFilenameMimeTypeUseCacheTempDirReceivedInvocations: [(mediaSource: MediaSource, filename: String?, mimeType: String, useCache: Bool, tempDir: String?)] {
|
|
get { getMediaFileMediaSourceFilenameMimeTypeUseCacheTempDirReceivedInvocationsLock.withLock { getMediaFileMediaSourceFilenameMimeTypeUseCacheTempDirUnderlyingReceivedInvocations } }
|
|
set { getMediaFileMediaSourceFilenameMimeTypeUseCacheTempDirReceivedInvocationsLock.withLock { getMediaFileMediaSourceFilenameMimeTypeUseCacheTempDirUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let getMediaFileMediaSourceFilenameMimeTypeUseCacheTempDirReturnValueLock = NSLock()
|
|
open var getMediaFileMediaSourceFilenameMimeTypeUseCacheTempDirUnderlyingReturnValue: MediaFileHandle!
|
|
open var getMediaFileMediaSourceFilenameMimeTypeUseCacheTempDirReturnValue: MediaFileHandle! {
|
|
get { getMediaFileMediaSourceFilenameMimeTypeUseCacheTempDirReturnValueLock.withLock { getMediaFileMediaSourceFilenameMimeTypeUseCacheTempDirUnderlyingReturnValue } }
|
|
set { getMediaFileMediaSourceFilenameMimeTypeUseCacheTempDirReturnValueLock.withLock { getMediaFileMediaSourceFilenameMimeTypeUseCacheTempDirUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var getMediaFileMediaSourceFilenameMimeTypeUseCacheTempDirClosure: ((MediaSource, String?, String, Bool, String?) async throws -> MediaFileHandle)?
|
|
|
|
open override func getMediaFile(mediaSource: MediaSource, filename: String?, mimeType: String, useCache: Bool, tempDir: String?) async throws -> MediaFileHandle {
|
|
if let error = getMediaFileMediaSourceFilenameMimeTypeUseCacheTempDirThrowableError {
|
|
throw error
|
|
}
|
|
getMediaFileMediaSourceFilenameMimeTypeUseCacheTempDirCallsCountLock.withLock { getMediaFileMediaSourceFilenameMimeTypeUseCacheTempDirUnderlyingCallsCount += 1 }
|
|
getMediaFileMediaSourceFilenameMimeTypeUseCacheTempDirReceivedArguments = (mediaSource: mediaSource, filename: filename, mimeType: mimeType, useCache: useCache, tempDir: tempDir)
|
|
getMediaFileMediaSourceFilenameMimeTypeUseCacheTempDirReceivedInvocationsLock.withLock { getMediaFileMediaSourceFilenameMimeTypeUseCacheTempDirUnderlyingReceivedInvocations.append((mediaSource: mediaSource, filename: filename, mimeType: mimeType, useCache: useCache, tempDir: tempDir)) }
|
|
if let getMediaFileMediaSourceFilenameMimeTypeUseCacheTempDirClosure = getMediaFileMediaSourceFilenameMimeTypeUseCacheTempDirClosure {
|
|
return try await getMediaFileMediaSourceFilenameMimeTypeUseCacheTempDirClosure(mediaSource, filename, mimeType, useCache, tempDir)
|
|
} else {
|
|
return getMediaFileMediaSourceFilenameMimeTypeUseCacheTempDirReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - getMediaPreviewDisplayPolicy
|
|
|
|
open var getMediaPreviewDisplayPolicyThrowableError: Error?
|
|
private let getMediaPreviewDisplayPolicyCallsCountLock = NSLock()
|
|
private var getMediaPreviewDisplayPolicyUnderlyingCallsCount = 0
|
|
open var getMediaPreviewDisplayPolicyCallsCount: Int {
|
|
get { getMediaPreviewDisplayPolicyCallsCountLock.withLock { getMediaPreviewDisplayPolicyUnderlyingCallsCount } }
|
|
set { getMediaPreviewDisplayPolicyCallsCountLock.withLock { getMediaPreviewDisplayPolicyUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var getMediaPreviewDisplayPolicyCalled: Bool {
|
|
return getMediaPreviewDisplayPolicyCallsCount > 0
|
|
}
|
|
|
|
private let getMediaPreviewDisplayPolicyReturnValueLock = NSLock()
|
|
open var getMediaPreviewDisplayPolicyUnderlyingReturnValue: MediaPreviews?
|
|
open var getMediaPreviewDisplayPolicyReturnValue: MediaPreviews? {
|
|
get { getMediaPreviewDisplayPolicyReturnValueLock.withLock { getMediaPreviewDisplayPolicyUnderlyingReturnValue } }
|
|
set { getMediaPreviewDisplayPolicyReturnValueLock.withLock { getMediaPreviewDisplayPolicyUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var getMediaPreviewDisplayPolicyClosure: (() async throws -> MediaPreviews?)?
|
|
|
|
open override func getMediaPreviewDisplayPolicy() async throws -> MediaPreviews? {
|
|
if let error = getMediaPreviewDisplayPolicyThrowableError {
|
|
throw error
|
|
}
|
|
getMediaPreviewDisplayPolicyCallsCountLock.withLock { getMediaPreviewDisplayPolicyUnderlyingCallsCount += 1 }
|
|
if let getMediaPreviewDisplayPolicyClosure = getMediaPreviewDisplayPolicyClosure {
|
|
return try await getMediaPreviewDisplayPolicyClosure()
|
|
} else {
|
|
return getMediaPreviewDisplayPolicyReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - getMediaThumbnail
|
|
|
|
open var getMediaThumbnailMediaSourceWidthHeightThrowableError: Error?
|
|
private let getMediaThumbnailMediaSourceWidthHeightCallsCountLock = NSLock()
|
|
private var getMediaThumbnailMediaSourceWidthHeightUnderlyingCallsCount = 0
|
|
open var getMediaThumbnailMediaSourceWidthHeightCallsCount: Int {
|
|
get { getMediaThumbnailMediaSourceWidthHeightCallsCountLock.withLock { getMediaThumbnailMediaSourceWidthHeightUnderlyingCallsCount } }
|
|
set { getMediaThumbnailMediaSourceWidthHeightCallsCountLock.withLock { getMediaThumbnailMediaSourceWidthHeightUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var getMediaThumbnailMediaSourceWidthHeightCalled: Bool {
|
|
return getMediaThumbnailMediaSourceWidthHeightCallsCount > 0
|
|
}
|
|
private let getMediaThumbnailMediaSourceWidthHeightReceivedArgumentsLock = NSLock()
|
|
private var getMediaThumbnailMediaSourceWidthHeightUnderlyingReceivedArguments: (mediaSource: MediaSource, width: UInt64, height: UInt64)?
|
|
open var getMediaThumbnailMediaSourceWidthHeightReceivedArguments: (mediaSource: MediaSource, width: UInt64, height: UInt64)? {
|
|
get { getMediaThumbnailMediaSourceWidthHeightReceivedArgumentsLock.withLock { getMediaThumbnailMediaSourceWidthHeightUnderlyingReceivedArguments } }
|
|
set { getMediaThumbnailMediaSourceWidthHeightReceivedArgumentsLock.withLock { getMediaThumbnailMediaSourceWidthHeightUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let getMediaThumbnailMediaSourceWidthHeightReceivedInvocationsLock = NSLock()
|
|
private var getMediaThumbnailMediaSourceWidthHeightUnderlyingReceivedInvocations: [(mediaSource: MediaSource, width: UInt64, height: UInt64)] = []
|
|
open var getMediaThumbnailMediaSourceWidthHeightReceivedInvocations: [(mediaSource: MediaSource, width: UInt64, height: UInt64)] {
|
|
get { getMediaThumbnailMediaSourceWidthHeightReceivedInvocationsLock.withLock { getMediaThumbnailMediaSourceWidthHeightUnderlyingReceivedInvocations } }
|
|
set { getMediaThumbnailMediaSourceWidthHeightReceivedInvocationsLock.withLock { getMediaThumbnailMediaSourceWidthHeightUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let getMediaThumbnailMediaSourceWidthHeightReturnValueLock = NSLock()
|
|
open var getMediaThumbnailMediaSourceWidthHeightUnderlyingReturnValue: Data!
|
|
open var getMediaThumbnailMediaSourceWidthHeightReturnValue: Data! {
|
|
get { getMediaThumbnailMediaSourceWidthHeightReturnValueLock.withLock { getMediaThumbnailMediaSourceWidthHeightUnderlyingReturnValue } }
|
|
set { getMediaThumbnailMediaSourceWidthHeightReturnValueLock.withLock { getMediaThumbnailMediaSourceWidthHeightUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var getMediaThumbnailMediaSourceWidthHeightClosure: ((MediaSource, UInt64, UInt64) async throws -> Data)?
|
|
|
|
open override func getMediaThumbnail(mediaSource: MediaSource, width: UInt64, height: UInt64) async throws -> Data {
|
|
if let error = getMediaThumbnailMediaSourceWidthHeightThrowableError {
|
|
throw error
|
|
}
|
|
getMediaThumbnailMediaSourceWidthHeightCallsCountLock.withLock { getMediaThumbnailMediaSourceWidthHeightUnderlyingCallsCount += 1 }
|
|
getMediaThumbnailMediaSourceWidthHeightReceivedArguments = (mediaSource: mediaSource, width: width, height: height)
|
|
getMediaThumbnailMediaSourceWidthHeightReceivedInvocationsLock.withLock { getMediaThumbnailMediaSourceWidthHeightUnderlyingReceivedInvocations.append((mediaSource: mediaSource, width: width, height: height)) }
|
|
if let getMediaThumbnailMediaSourceWidthHeightClosure = getMediaThumbnailMediaSourceWidthHeightClosure {
|
|
return try await getMediaThumbnailMediaSourceWidthHeightClosure(mediaSource, width, height)
|
|
} else {
|
|
return getMediaThumbnailMediaSourceWidthHeightReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - getNotificationSettings
|
|
|
|
private let getNotificationSettingsCallsCountLock = NSLock()
|
|
private var getNotificationSettingsUnderlyingCallsCount = 0
|
|
open var getNotificationSettingsCallsCount: Int {
|
|
get { getNotificationSettingsCallsCountLock.withLock { getNotificationSettingsUnderlyingCallsCount } }
|
|
set { getNotificationSettingsCallsCountLock.withLock { getNotificationSettingsUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var getNotificationSettingsCalled: Bool {
|
|
return getNotificationSettingsCallsCount > 0
|
|
}
|
|
|
|
private let getNotificationSettingsReturnValueLock = NSLock()
|
|
open var getNotificationSettingsUnderlyingReturnValue: NotificationSettings!
|
|
open var getNotificationSettingsReturnValue: NotificationSettings! {
|
|
get { getNotificationSettingsReturnValueLock.withLock { getNotificationSettingsUnderlyingReturnValue } }
|
|
set { getNotificationSettingsReturnValueLock.withLock { getNotificationSettingsUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var getNotificationSettingsClosure: (() async -> NotificationSettings)?
|
|
|
|
open override func getNotificationSettings() async -> NotificationSettings {
|
|
getNotificationSettingsCallsCountLock.withLock { getNotificationSettingsUnderlyingCallsCount += 1 }
|
|
if let getNotificationSettingsClosure = getNotificationSettingsClosure {
|
|
return await getNotificationSettingsClosure()
|
|
} else {
|
|
return getNotificationSettingsReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - getProfile
|
|
|
|
open var getProfileUserIdThrowableError: Error?
|
|
private let getProfileUserIdCallsCountLock = NSLock()
|
|
private var getProfileUserIdUnderlyingCallsCount = 0
|
|
open var getProfileUserIdCallsCount: Int {
|
|
get { getProfileUserIdCallsCountLock.withLock { getProfileUserIdUnderlyingCallsCount } }
|
|
set { getProfileUserIdCallsCountLock.withLock { getProfileUserIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var getProfileUserIdCalled: Bool {
|
|
return getProfileUserIdCallsCount > 0
|
|
}
|
|
private let getProfileUserIdReceivedUserIdLock = NSLock()
|
|
private var getProfileUserIdUnderlyingReceivedUserId: String?
|
|
open var getProfileUserIdReceivedUserId: String? {
|
|
get { getProfileUserIdReceivedUserIdLock.withLock { getProfileUserIdUnderlyingReceivedUserId } }
|
|
set { getProfileUserIdReceivedUserIdLock.withLock { getProfileUserIdUnderlyingReceivedUserId = newValue } }
|
|
}
|
|
private let getProfileUserIdReceivedInvocationsLock = NSLock()
|
|
private var getProfileUserIdUnderlyingReceivedInvocations: [String] = []
|
|
open var getProfileUserIdReceivedInvocations: [String] {
|
|
get { getProfileUserIdReceivedInvocationsLock.withLock { getProfileUserIdUnderlyingReceivedInvocations } }
|
|
set { getProfileUserIdReceivedInvocationsLock.withLock { getProfileUserIdUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let getProfileUserIdReturnValueLock = NSLock()
|
|
open var getProfileUserIdUnderlyingReturnValue: UserProfile!
|
|
open var getProfileUserIdReturnValue: UserProfile! {
|
|
get { getProfileUserIdReturnValueLock.withLock { getProfileUserIdUnderlyingReturnValue } }
|
|
set { getProfileUserIdReturnValueLock.withLock { getProfileUserIdUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var getProfileUserIdClosure: ((String) async throws -> UserProfile)?
|
|
|
|
open override func getProfile(userId: String) async throws -> UserProfile {
|
|
if let error = getProfileUserIdThrowableError {
|
|
throw error
|
|
}
|
|
getProfileUserIdCallsCountLock.withLock { getProfileUserIdUnderlyingCallsCount += 1 }
|
|
getProfileUserIdReceivedUserId = userId
|
|
getProfileUserIdReceivedInvocationsLock.withLock { getProfileUserIdUnderlyingReceivedInvocations.append(userId) }
|
|
if let getProfileUserIdClosure = getProfileUserIdClosure {
|
|
return try await getProfileUserIdClosure(userId)
|
|
} else {
|
|
return getProfileUserIdReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - getRecentlyVisitedRooms
|
|
|
|
open var getRecentlyVisitedRoomsThrowableError: Error?
|
|
private let getRecentlyVisitedRoomsCallsCountLock = NSLock()
|
|
private var getRecentlyVisitedRoomsUnderlyingCallsCount = 0
|
|
open var getRecentlyVisitedRoomsCallsCount: Int {
|
|
get { getRecentlyVisitedRoomsCallsCountLock.withLock { getRecentlyVisitedRoomsUnderlyingCallsCount } }
|
|
set { getRecentlyVisitedRoomsCallsCountLock.withLock { getRecentlyVisitedRoomsUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var getRecentlyVisitedRoomsCalled: Bool {
|
|
return getRecentlyVisitedRoomsCallsCount > 0
|
|
}
|
|
|
|
private let getRecentlyVisitedRoomsReturnValueLock = NSLock()
|
|
open var getRecentlyVisitedRoomsUnderlyingReturnValue: [String]!
|
|
open var getRecentlyVisitedRoomsReturnValue: [String]! {
|
|
get { getRecentlyVisitedRoomsReturnValueLock.withLock { getRecentlyVisitedRoomsUnderlyingReturnValue } }
|
|
set { getRecentlyVisitedRoomsReturnValueLock.withLock { getRecentlyVisitedRoomsUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var getRecentlyVisitedRoomsClosure: (() async throws -> [String])?
|
|
|
|
open override func getRecentlyVisitedRooms() async throws -> [String] {
|
|
if let error = getRecentlyVisitedRoomsThrowableError {
|
|
throw error
|
|
}
|
|
getRecentlyVisitedRoomsCallsCountLock.withLock { getRecentlyVisitedRoomsUnderlyingCallsCount += 1 }
|
|
if let getRecentlyVisitedRoomsClosure = getRecentlyVisitedRoomsClosure {
|
|
return try await getRecentlyVisitedRoomsClosure()
|
|
} else {
|
|
return getRecentlyVisitedRoomsReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - getRoom
|
|
|
|
open var getRoomRoomIdThrowableError: Error?
|
|
private let getRoomRoomIdCallsCountLock = NSLock()
|
|
private var getRoomRoomIdUnderlyingCallsCount = 0
|
|
open var getRoomRoomIdCallsCount: Int {
|
|
get { getRoomRoomIdCallsCountLock.withLock { getRoomRoomIdUnderlyingCallsCount } }
|
|
set { getRoomRoomIdCallsCountLock.withLock { getRoomRoomIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var getRoomRoomIdCalled: Bool {
|
|
return getRoomRoomIdCallsCount > 0
|
|
}
|
|
private let getRoomRoomIdReceivedRoomIdLock = NSLock()
|
|
private var getRoomRoomIdUnderlyingReceivedRoomId: String?
|
|
open var getRoomRoomIdReceivedRoomId: String? {
|
|
get { getRoomRoomIdReceivedRoomIdLock.withLock { getRoomRoomIdUnderlyingReceivedRoomId } }
|
|
set { getRoomRoomIdReceivedRoomIdLock.withLock { getRoomRoomIdUnderlyingReceivedRoomId = newValue } }
|
|
}
|
|
private let getRoomRoomIdReceivedInvocationsLock = NSLock()
|
|
private var getRoomRoomIdUnderlyingReceivedInvocations: [String] = []
|
|
open var getRoomRoomIdReceivedInvocations: [String] {
|
|
get { getRoomRoomIdReceivedInvocationsLock.withLock { getRoomRoomIdUnderlyingReceivedInvocations } }
|
|
set { getRoomRoomIdReceivedInvocationsLock.withLock { getRoomRoomIdUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let getRoomRoomIdReturnValueLock = NSLock()
|
|
open var getRoomRoomIdUnderlyingReturnValue: Room?
|
|
open var getRoomRoomIdReturnValue: Room? {
|
|
get { getRoomRoomIdReturnValueLock.withLock { getRoomRoomIdUnderlyingReturnValue } }
|
|
set { getRoomRoomIdReturnValueLock.withLock { getRoomRoomIdUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var getRoomRoomIdClosure: ((String) throws -> Room?)?
|
|
|
|
open override func getRoom(roomId: String) throws -> Room? {
|
|
if let error = getRoomRoomIdThrowableError {
|
|
throw error
|
|
}
|
|
getRoomRoomIdCallsCountLock.withLock { getRoomRoomIdUnderlyingCallsCount += 1 }
|
|
getRoomRoomIdReceivedRoomId = roomId
|
|
getRoomRoomIdReceivedInvocationsLock.withLock { getRoomRoomIdUnderlyingReceivedInvocations.append(roomId) }
|
|
if let getRoomRoomIdClosure = getRoomRoomIdClosure {
|
|
return try getRoomRoomIdClosure(roomId)
|
|
} else {
|
|
return getRoomRoomIdReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - getRoomPreviewFromRoomAlias
|
|
|
|
open var getRoomPreviewFromRoomAliasRoomAliasThrowableError: Error?
|
|
private let getRoomPreviewFromRoomAliasRoomAliasCallsCountLock = NSLock()
|
|
private var getRoomPreviewFromRoomAliasRoomAliasUnderlyingCallsCount = 0
|
|
open var getRoomPreviewFromRoomAliasRoomAliasCallsCount: Int {
|
|
get { getRoomPreviewFromRoomAliasRoomAliasCallsCountLock.withLock { getRoomPreviewFromRoomAliasRoomAliasUnderlyingCallsCount } }
|
|
set { getRoomPreviewFromRoomAliasRoomAliasCallsCountLock.withLock { getRoomPreviewFromRoomAliasRoomAliasUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var getRoomPreviewFromRoomAliasRoomAliasCalled: Bool {
|
|
return getRoomPreviewFromRoomAliasRoomAliasCallsCount > 0
|
|
}
|
|
private let getRoomPreviewFromRoomAliasRoomAliasReceivedRoomAliasLock = NSLock()
|
|
private var getRoomPreviewFromRoomAliasRoomAliasUnderlyingReceivedRoomAlias: String?
|
|
open var getRoomPreviewFromRoomAliasRoomAliasReceivedRoomAlias: String? {
|
|
get { getRoomPreviewFromRoomAliasRoomAliasReceivedRoomAliasLock.withLock { getRoomPreviewFromRoomAliasRoomAliasUnderlyingReceivedRoomAlias } }
|
|
set { getRoomPreviewFromRoomAliasRoomAliasReceivedRoomAliasLock.withLock { getRoomPreviewFromRoomAliasRoomAliasUnderlyingReceivedRoomAlias = newValue } }
|
|
}
|
|
private let getRoomPreviewFromRoomAliasRoomAliasReceivedInvocationsLock = NSLock()
|
|
private var getRoomPreviewFromRoomAliasRoomAliasUnderlyingReceivedInvocations: [String] = []
|
|
open var getRoomPreviewFromRoomAliasRoomAliasReceivedInvocations: [String] {
|
|
get { getRoomPreviewFromRoomAliasRoomAliasReceivedInvocationsLock.withLock { getRoomPreviewFromRoomAliasRoomAliasUnderlyingReceivedInvocations } }
|
|
set { getRoomPreviewFromRoomAliasRoomAliasReceivedInvocationsLock.withLock { getRoomPreviewFromRoomAliasRoomAliasUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let getRoomPreviewFromRoomAliasRoomAliasReturnValueLock = NSLock()
|
|
open var getRoomPreviewFromRoomAliasRoomAliasUnderlyingReturnValue: RoomPreview!
|
|
open var getRoomPreviewFromRoomAliasRoomAliasReturnValue: RoomPreview! {
|
|
get { getRoomPreviewFromRoomAliasRoomAliasReturnValueLock.withLock { getRoomPreviewFromRoomAliasRoomAliasUnderlyingReturnValue } }
|
|
set { getRoomPreviewFromRoomAliasRoomAliasReturnValueLock.withLock { getRoomPreviewFromRoomAliasRoomAliasUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var getRoomPreviewFromRoomAliasRoomAliasClosure: ((String) async throws -> RoomPreview)?
|
|
|
|
open override func getRoomPreviewFromRoomAlias(roomAlias: String) async throws -> RoomPreview {
|
|
if let error = getRoomPreviewFromRoomAliasRoomAliasThrowableError {
|
|
throw error
|
|
}
|
|
getRoomPreviewFromRoomAliasRoomAliasCallsCountLock.withLock { getRoomPreviewFromRoomAliasRoomAliasUnderlyingCallsCount += 1 }
|
|
getRoomPreviewFromRoomAliasRoomAliasReceivedRoomAlias = roomAlias
|
|
getRoomPreviewFromRoomAliasRoomAliasReceivedInvocationsLock.withLock { getRoomPreviewFromRoomAliasRoomAliasUnderlyingReceivedInvocations.append(roomAlias) }
|
|
if let getRoomPreviewFromRoomAliasRoomAliasClosure = getRoomPreviewFromRoomAliasRoomAliasClosure {
|
|
return try await getRoomPreviewFromRoomAliasRoomAliasClosure(roomAlias)
|
|
} else {
|
|
return getRoomPreviewFromRoomAliasRoomAliasReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - getRoomPreviewFromRoomId
|
|
|
|
open var getRoomPreviewFromRoomIdRoomIdViaServersThrowableError: Error?
|
|
private let getRoomPreviewFromRoomIdRoomIdViaServersCallsCountLock = NSLock()
|
|
private var getRoomPreviewFromRoomIdRoomIdViaServersUnderlyingCallsCount = 0
|
|
open var getRoomPreviewFromRoomIdRoomIdViaServersCallsCount: Int {
|
|
get { getRoomPreviewFromRoomIdRoomIdViaServersCallsCountLock.withLock { getRoomPreviewFromRoomIdRoomIdViaServersUnderlyingCallsCount } }
|
|
set { getRoomPreviewFromRoomIdRoomIdViaServersCallsCountLock.withLock { getRoomPreviewFromRoomIdRoomIdViaServersUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var getRoomPreviewFromRoomIdRoomIdViaServersCalled: Bool {
|
|
return getRoomPreviewFromRoomIdRoomIdViaServersCallsCount > 0
|
|
}
|
|
private let getRoomPreviewFromRoomIdRoomIdViaServersReceivedArgumentsLock = NSLock()
|
|
private var getRoomPreviewFromRoomIdRoomIdViaServersUnderlyingReceivedArguments: (roomId: String, viaServers: [String])?
|
|
open var getRoomPreviewFromRoomIdRoomIdViaServersReceivedArguments: (roomId: String, viaServers: [String])? {
|
|
get { getRoomPreviewFromRoomIdRoomIdViaServersReceivedArgumentsLock.withLock { getRoomPreviewFromRoomIdRoomIdViaServersUnderlyingReceivedArguments } }
|
|
set { getRoomPreviewFromRoomIdRoomIdViaServersReceivedArgumentsLock.withLock { getRoomPreviewFromRoomIdRoomIdViaServersUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let getRoomPreviewFromRoomIdRoomIdViaServersReceivedInvocationsLock = NSLock()
|
|
private var getRoomPreviewFromRoomIdRoomIdViaServersUnderlyingReceivedInvocations: [(roomId: String, viaServers: [String])] = []
|
|
open var getRoomPreviewFromRoomIdRoomIdViaServersReceivedInvocations: [(roomId: String, viaServers: [String])] {
|
|
get { getRoomPreviewFromRoomIdRoomIdViaServersReceivedInvocationsLock.withLock { getRoomPreviewFromRoomIdRoomIdViaServersUnderlyingReceivedInvocations } }
|
|
set { getRoomPreviewFromRoomIdRoomIdViaServersReceivedInvocationsLock.withLock { getRoomPreviewFromRoomIdRoomIdViaServersUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let getRoomPreviewFromRoomIdRoomIdViaServersReturnValueLock = NSLock()
|
|
open var getRoomPreviewFromRoomIdRoomIdViaServersUnderlyingReturnValue: RoomPreview!
|
|
open var getRoomPreviewFromRoomIdRoomIdViaServersReturnValue: RoomPreview! {
|
|
get { getRoomPreviewFromRoomIdRoomIdViaServersReturnValueLock.withLock { getRoomPreviewFromRoomIdRoomIdViaServersUnderlyingReturnValue } }
|
|
set { getRoomPreviewFromRoomIdRoomIdViaServersReturnValueLock.withLock { getRoomPreviewFromRoomIdRoomIdViaServersUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var getRoomPreviewFromRoomIdRoomIdViaServersClosure: ((String, [String]) async throws -> RoomPreview)?
|
|
|
|
open override func getRoomPreviewFromRoomId(roomId: String, viaServers: [String]) async throws -> RoomPreview {
|
|
if let error = getRoomPreviewFromRoomIdRoomIdViaServersThrowableError {
|
|
throw error
|
|
}
|
|
getRoomPreviewFromRoomIdRoomIdViaServersCallsCountLock.withLock { getRoomPreviewFromRoomIdRoomIdViaServersUnderlyingCallsCount += 1 }
|
|
getRoomPreviewFromRoomIdRoomIdViaServersReceivedArguments = (roomId: roomId, viaServers: viaServers)
|
|
getRoomPreviewFromRoomIdRoomIdViaServersReceivedInvocationsLock.withLock { getRoomPreviewFromRoomIdRoomIdViaServersUnderlyingReceivedInvocations.append((roomId: roomId, viaServers: viaServers)) }
|
|
if let getRoomPreviewFromRoomIdRoomIdViaServersClosure = getRoomPreviewFromRoomIdRoomIdViaServersClosure {
|
|
return try await getRoomPreviewFromRoomIdRoomIdViaServersClosure(roomId, viaServers)
|
|
} else {
|
|
return getRoomPreviewFromRoomIdRoomIdViaServersReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - getSessionVerificationController
|
|
|
|
open var getSessionVerificationControllerThrowableError: Error?
|
|
private let getSessionVerificationControllerCallsCountLock = NSLock()
|
|
private var getSessionVerificationControllerUnderlyingCallsCount = 0
|
|
open var getSessionVerificationControllerCallsCount: Int {
|
|
get { getSessionVerificationControllerCallsCountLock.withLock { getSessionVerificationControllerUnderlyingCallsCount } }
|
|
set { getSessionVerificationControllerCallsCountLock.withLock { getSessionVerificationControllerUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var getSessionVerificationControllerCalled: Bool {
|
|
return getSessionVerificationControllerCallsCount > 0
|
|
}
|
|
|
|
private let getSessionVerificationControllerReturnValueLock = NSLock()
|
|
open var getSessionVerificationControllerUnderlyingReturnValue: SessionVerificationController!
|
|
open var getSessionVerificationControllerReturnValue: SessionVerificationController! {
|
|
get { getSessionVerificationControllerReturnValueLock.withLock { getSessionVerificationControllerUnderlyingReturnValue } }
|
|
set { getSessionVerificationControllerReturnValueLock.withLock { getSessionVerificationControllerUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var getSessionVerificationControllerClosure: (() async throws -> SessionVerificationController)?
|
|
|
|
open override func getSessionVerificationController() async throws -> SessionVerificationController {
|
|
if let error = getSessionVerificationControllerThrowableError {
|
|
throw error
|
|
}
|
|
getSessionVerificationControllerCallsCountLock.withLock { getSessionVerificationControllerUnderlyingCallsCount += 1 }
|
|
if let getSessionVerificationControllerClosure = getSessionVerificationControllerClosure {
|
|
return try await getSessionVerificationControllerClosure()
|
|
} else {
|
|
return getSessionVerificationControllerReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - getStoreSizes
|
|
|
|
open var getStoreSizesThrowableError: Error?
|
|
private let getStoreSizesCallsCountLock = NSLock()
|
|
private var getStoreSizesUnderlyingCallsCount = 0
|
|
open var getStoreSizesCallsCount: Int {
|
|
get { getStoreSizesCallsCountLock.withLock { getStoreSizesUnderlyingCallsCount } }
|
|
set { getStoreSizesCallsCountLock.withLock { getStoreSizesUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var getStoreSizesCalled: Bool {
|
|
return getStoreSizesCallsCount > 0
|
|
}
|
|
|
|
private let getStoreSizesReturnValueLock = NSLock()
|
|
open var getStoreSizesUnderlyingReturnValue: StoreSizes!
|
|
open var getStoreSizesReturnValue: StoreSizes! {
|
|
get { getStoreSizesReturnValueLock.withLock { getStoreSizesUnderlyingReturnValue } }
|
|
set { getStoreSizesReturnValueLock.withLock { getStoreSizesUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var getStoreSizesClosure: (() async throws -> StoreSizes)?
|
|
|
|
open override func getStoreSizes() async throws -> StoreSizes {
|
|
if let error = getStoreSizesThrowableError {
|
|
throw error
|
|
}
|
|
getStoreSizesCallsCountLock.withLock { getStoreSizesUnderlyingCallsCount += 1 }
|
|
if let getStoreSizesClosure = getStoreSizesClosure {
|
|
return try await getStoreSizesClosure()
|
|
} else {
|
|
return getStoreSizesReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - getUrl
|
|
|
|
open var getUrlUrlThrowableError: Error?
|
|
private let getUrlUrlCallsCountLock = NSLock()
|
|
private var getUrlUrlUnderlyingCallsCount = 0
|
|
open var getUrlUrlCallsCount: Int {
|
|
get { getUrlUrlCallsCountLock.withLock { getUrlUrlUnderlyingCallsCount } }
|
|
set { getUrlUrlCallsCountLock.withLock { getUrlUrlUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var getUrlUrlCalled: Bool {
|
|
return getUrlUrlCallsCount > 0
|
|
}
|
|
private let getUrlUrlReceivedUrlLock = NSLock()
|
|
private var getUrlUrlUnderlyingReceivedUrl: String?
|
|
open var getUrlUrlReceivedUrl: String? {
|
|
get { getUrlUrlReceivedUrlLock.withLock { getUrlUrlUnderlyingReceivedUrl } }
|
|
set { getUrlUrlReceivedUrlLock.withLock { getUrlUrlUnderlyingReceivedUrl = newValue } }
|
|
}
|
|
private let getUrlUrlReceivedInvocationsLock = NSLock()
|
|
private var getUrlUrlUnderlyingReceivedInvocations: [String] = []
|
|
open var getUrlUrlReceivedInvocations: [String] {
|
|
get { getUrlUrlReceivedInvocationsLock.withLock { getUrlUrlUnderlyingReceivedInvocations } }
|
|
set { getUrlUrlReceivedInvocationsLock.withLock { getUrlUrlUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let getUrlUrlReturnValueLock = NSLock()
|
|
open var getUrlUrlUnderlyingReturnValue: Data!
|
|
open var getUrlUrlReturnValue: Data! {
|
|
get { getUrlUrlReturnValueLock.withLock { getUrlUrlUnderlyingReturnValue } }
|
|
set { getUrlUrlReturnValueLock.withLock { getUrlUrlUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var getUrlUrlClosure: ((String) async throws -> Data)?
|
|
|
|
open override func getUrl(url: String) async throws -> Data {
|
|
if let error = getUrlUrlThrowableError {
|
|
throw error
|
|
}
|
|
getUrlUrlCallsCountLock.withLock { getUrlUrlUnderlyingCallsCount += 1 }
|
|
getUrlUrlReceivedUrl = url
|
|
getUrlUrlReceivedInvocationsLock.withLock { getUrlUrlUnderlyingReceivedInvocations.append(url) }
|
|
if let getUrlUrlClosure = getUrlUrlClosure {
|
|
return try await getUrlUrlClosure(url)
|
|
} else {
|
|
return getUrlUrlReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - homeserver
|
|
|
|
private let homeserverCallsCountLock = NSLock()
|
|
private var homeserverUnderlyingCallsCount = 0
|
|
open var homeserverCallsCount: Int {
|
|
get { homeserverCallsCountLock.withLock { homeserverUnderlyingCallsCount } }
|
|
set { homeserverCallsCountLock.withLock { homeserverUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var homeserverCalled: Bool {
|
|
return homeserverCallsCount > 0
|
|
}
|
|
|
|
private let homeserverReturnValueLock = NSLock()
|
|
open var homeserverUnderlyingReturnValue: String!
|
|
open var homeserverReturnValue: String! {
|
|
get { homeserverReturnValueLock.withLock { homeserverUnderlyingReturnValue } }
|
|
set { homeserverReturnValueLock.withLock { homeserverUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var homeserverClosure: (() -> String)?
|
|
|
|
open override func homeserver() -> String {
|
|
homeserverCallsCountLock.withLock { homeserverUnderlyingCallsCount += 1 }
|
|
if let homeserverClosure = homeserverClosure {
|
|
return homeserverClosure()
|
|
} else {
|
|
return homeserverReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - homeserverCapabilities
|
|
|
|
private let homeserverCapabilitiesCallsCountLock = NSLock()
|
|
private var homeserverCapabilitiesUnderlyingCallsCount = 0
|
|
open var homeserverCapabilitiesCallsCount: Int {
|
|
get { homeserverCapabilitiesCallsCountLock.withLock { homeserverCapabilitiesUnderlyingCallsCount } }
|
|
set { homeserverCapabilitiesCallsCountLock.withLock { homeserverCapabilitiesUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var homeserverCapabilitiesCalled: Bool {
|
|
return homeserverCapabilitiesCallsCount > 0
|
|
}
|
|
|
|
private let homeserverCapabilitiesReturnValueLock = NSLock()
|
|
open var homeserverCapabilitiesUnderlyingReturnValue: HomeserverCapabilities!
|
|
open var homeserverCapabilitiesReturnValue: HomeserverCapabilities! {
|
|
get { homeserverCapabilitiesReturnValueLock.withLock { homeserverCapabilitiesUnderlyingReturnValue } }
|
|
set { homeserverCapabilitiesReturnValueLock.withLock { homeserverCapabilitiesUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var homeserverCapabilitiesClosure: (() -> HomeserverCapabilities)?
|
|
|
|
open override func homeserverCapabilities() -> HomeserverCapabilities {
|
|
homeserverCapabilitiesCallsCountLock.withLock { homeserverCapabilitiesUnderlyingCallsCount += 1 }
|
|
if let homeserverCapabilitiesClosure = homeserverCapabilitiesClosure {
|
|
return homeserverCapabilitiesClosure()
|
|
} else {
|
|
return homeserverCapabilitiesReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - homeserverLoginDetails
|
|
|
|
private let homeserverLoginDetailsCallsCountLock = NSLock()
|
|
private var homeserverLoginDetailsUnderlyingCallsCount = 0
|
|
open var homeserverLoginDetailsCallsCount: Int {
|
|
get { homeserverLoginDetailsCallsCountLock.withLock { homeserverLoginDetailsUnderlyingCallsCount } }
|
|
set { homeserverLoginDetailsCallsCountLock.withLock { homeserverLoginDetailsUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var homeserverLoginDetailsCalled: Bool {
|
|
return homeserverLoginDetailsCallsCount > 0
|
|
}
|
|
|
|
private let homeserverLoginDetailsReturnValueLock = NSLock()
|
|
open var homeserverLoginDetailsUnderlyingReturnValue: HomeserverLoginDetails!
|
|
open var homeserverLoginDetailsReturnValue: HomeserverLoginDetails! {
|
|
get { homeserverLoginDetailsReturnValueLock.withLock { homeserverLoginDetailsUnderlyingReturnValue } }
|
|
set { homeserverLoginDetailsReturnValueLock.withLock { homeserverLoginDetailsUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var homeserverLoginDetailsClosure: (() async -> HomeserverLoginDetails)?
|
|
|
|
open override func homeserverLoginDetails() async -> HomeserverLoginDetails {
|
|
homeserverLoginDetailsCallsCountLock.withLock { homeserverLoginDetailsUnderlyingCallsCount += 1 }
|
|
if let homeserverLoginDetailsClosure = homeserverLoginDetailsClosure {
|
|
return await homeserverLoginDetailsClosure()
|
|
} else {
|
|
return homeserverLoginDetailsReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - ignoreUser
|
|
|
|
open var ignoreUserUserIdThrowableError: Error?
|
|
private let ignoreUserUserIdCallsCountLock = NSLock()
|
|
private var ignoreUserUserIdUnderlyingCallsCount = 0
|
|
open var ignoreUserUserIdCallsCount: Int {
|
|
get { ignoreUserUserIdCallsCountLock.withLock { ignoreUserUserIdUnderlyingCallsCount } }
|
|
set { ignoreUserUserIdCallsCountLock.withLock { ignoreUserUserIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var ignoreUserUserIdCalled: Bool {
|
|
return ignoreUserUserIdCallsCount > 0
|
|
}
|
|
private let ignoreUserUserIdReceivedUserIdLock = NSLock()
|
|
private var ignoreUserUserIdUnderlyingReceivedUserId: String?
|
|
open var ignoreUserUserIdReceivedUserId: String? {
|
|
get { ignoreUserUserIdReceivedUserIdLock.withLock { ignoreUserUserIdUnderlyingReceivedUserId } }
|
|
set { ignoreUserUserIdReceivedUserIdLock.withLock { ignoreUserUserIdUnderlyingReceivedUserId = newValue } }
|
|
}
|
|
private let ignoreUserUserIdReceivedInvocationsLock = NSLock()
|
|
private var ignoreUserUserIdUnderlyingReceivedInvocations: [String] = []
|
|
open var ignoreUserUserIdReceivedInvocations: [String] {
|
|
get { ignoreUserUserIdReceivedInvocationsLock.withLock { ignoreUserUserIdUnderlyingReceivedInvocations } }
|
|
set { ignoreUserUserIdReceivedInvocationsLock.withLock { ignoreUserUserIdUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var ignoreUserUserIdClosure: ((String) async throws -> Void)?
|
|
|
|
open override func ignoreUser(userId: String) async throws {
|
|
if let error = ignoreUserUserIdThrowableError {
|
|
throw error
|
|
}
|
|
ignoreUserUserIdCallsCountLock.withLock { ignoreUserUserIdUnderlyingCallsCount += 1 }
|
|
ignoreUserUserIdReceivedUserId = userId
|
|
ignoreUserUserIdReceivedInvocationsLock.withLock { ignoreUserUserIdUnderlyingReceivedInvocations.append(userId) }
|
|
try await ignoreUserUserIdClosure?(userId)
|
|
}
|
|
|
|
//MARK: - ignoredUsers
|
|
|
|
open var ignoredUsersThrowableError: Error?
|
|
private let ignoredUsersCallsCountLock = NSLock()
|
|
private var ignoredUsersUnderlyingCallsCount = 0
|
|
open var ignoredUsersCallsCount: Int {
|
|
get { ignoredUsersCallsCountLock.withLock { ignoredUsersUnderlyingCallsCount } }
|
|
set { ignoredUsersCallsCountLock.withLock { ignoredUsersUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var ignoredUsersCalled: Bool {
|
|
return ignoredUsersCallsCount > 0
|
|
}
|
|
|
|
private let ignoredUsersReturnValueLock = NSLock()
|
|
open var ignoredUsersUnderlyingReturnValue: [String]!
|
|
open var ignoredUsersReturnValue: [String]! {
|
|
get { ignoredUsersReturnValueLock.withLock { ignoredUsersUnderlyingReturnValue } }
|
|
set { ignoredUsersReturnValueLock.withLock { ignoredUsersUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var ignoredUsersClosure: (() async throws -> [String])?
|
|
|
|
open override func ignoredUsers() async throws -> [String] {
|
|
if let error = ignoredUsersThrowableError {
|
|
throw error
|
|
}
|
|
ignoredUsersCallsCountLock.withLock { ignoredUsersUnderlyingCallsCount += 1 }
|
|
if let ignoredUsersClosure = ignoredUsersClosure {
|
|
return try await ignoredUsersClosure()
|
|
} else {
|
|
return ignoredUsersReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - isLivekitRtcSupported
|
|
|
|
open var isLivekitRtcSupportedThrowableError: Error?
|
|
private let isLivekitRtcSupportedCallsCountLock = NSLock()
|
|
private var isLivekitRtcSupportedUnderlyingCallsCount = 0
|
|
open var isLivekitRtcSupportedCallsCount: Int {
|
|
get { isLivekitRtcSupportedCallsCountLock.withLock { isLivekitRtcSupportedUnderlyingCallsCount } }
|
|
set { isLivekitRtcSupportedCallsCountLock.withLock { isLivekitRtcSupportedUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var isLivekitRtcSupportedCalled: Bool {
|
|
return isLivekitRtcSupportedCallsCount > 0
|
|
}
|
|
|
|
private let isLivekitRtcSupportedReturnValueLock = NSLock()
|
|
open var isLivekitRtcSupportedUnderlyingReturnValue: Bool!
|
|
open var isLivekitRtcSupportedReturnValue: Bool! {
|
|
get { isLivekitRtcSupportedReturnValueLock.withLock { isLivekitRtcSupportedUnderlyingReturnValue } }
|
|
set { isLivekitRtcSupportedReturnValueLock.withLock { isLivekitRtcSupportedUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var isLivekitRtcSupportedClosure: (() async throws -> Bool)?
|
|
|
|
open override func isLivekitRtcSupported() async throws -> Bool {
|
|
if let error = isLivekitRtcSupportedThrowableError {
|
|
throw error
|
|
}
|
|
isLivekitRtcSupportedCallsCountLock.withLock { isLivekitRtcSupportedUnderlyingCallsCount += 1 }
|
|
if let isLivekitRtcSupportedClosure = isLivekitRtcSupportedClosure {
|
|
return try await isLivekitRtcSupportedClosure()
|
|
} else {
|
|
return isLivekitRtcSupportedReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - isLoginWithQrCodeSupported
|
|
|
|
open var isLoginWithQrCodeSupportedThrowableError: Error?
|
|
private let isLoginWithQrCodeSupportedCallsCountLock = NSLock()
|
|
private var isLoginWithQrCodeSupportedUnderlyingCallsCount = 0
|
|
open var isLoginWithQrCodeSupportedCallsCount: Int {
|
|
get { isLoginWithQrCodeSupportedCallsCountLock.withLock { isLoginWithQrCodeSupportedUnderlyingCallsCount } }
|
|
set { isLoginWithQrCodeSupportedCallsCountLock.withLock { isLoginWithQrCodeSupportedUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var isLoginWithQrCodeSupportedCalled: Bool {
|
|
return isLoginWithQrCodeSupportedCallsCount > 0
|
|
}
|
|
|
|
private let isLoginWithQrCodeSupportedReturnValueLock = NSLock()
|
|
open var isLoginWithQrCodeSupportedUnderlyingReturnValue: Bool!
|
|
open var isLoginWithQrCodeSupportedReturnValue: Bool! {
|
|
get { isLoginWithQrCodeSupportedReturnValueLock.withLock { isLoginWithQrCodeSupportedUnderlyingReturnValue } }
|
|
set { isLoginWithQrCodeSupportedReturnValueLock.withLock { isLoginWithQrCodeSupportedUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var isLoginWithQrCodeSupportedClosure: (() async throws -> Bool)?
|
|
|
|
open override func isLoginWithQrCodeSupported() async throws -> Bool {
|
|
if let error = isLoginWithQrCodeSupportedThrowableError {
|
|
throw error
|
|
}
|
|
isLoginWithQrCodeSupportedCallsCountLock.withLock { isLoginWithQrCodeSupportedUnderlyingCallsCount += 1 }
|
|
if let isLoginWithQrCodeSupportedClosure = isLoginWithQrCodeSupportedClosure {
|
|
return try await isLoginWithQrCodeSupportedClosure()
|
|
} else {
|
|
return isLoginWithQrCodeSupportedReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - isReportRoomApiSupported
|
|
|
|
open var isReportRoomApiSupportedThrowableError: Error?
|
|
private let isReportRoomApiSupportedCallsCountLock = NSLock()
|
|
private var isReportRoomApiSupportedUnderlyingCallsCount = 0
|
|
open var isReportRoomApiSupportedCallsCount: Int {
|
|
get { isReportRoomApiSupportedCallsCountLock.withLock { isReportRoomApiSupportedUnderlyingCallsCount } }
|
|
set { isReportRoomApiSupportedCallsCountLock.withLock { isReportRoomApiSupportedUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var isReportRoomApiSupportedCalled: Bool {
|
|
return isReportRoomApiSupportedCallsCount > 0
|
|
}
|
|
|
|
private let isReportRoomApiSupportedReturnValueLock = NSLock()
|
|
open var isReportRoomApiSupportedUnderlyingReturnValue: Bool!
|
|
open var isReportRoomApiSupportedReturnValue: Bool! {
|
|
get { isReportRoomApiSupportedReturnValueLock.withLock { isReportRoomApiSupportedUnderlyingReturnValue } }
|
|
set { isReportRoomApiSupportedReturnValueLock.withLock { isReportRoomApiSupportedUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var isReportRoomApiSupportedClosure: (() async throws -> Bool)?
|
|
|
|
open override func isReportRoomApiSupported() async throws -> Bool {
|
|
if let error = isReportRoomApiSupportedThrowableError {
|
|
throw error
|
|
}
|
|
isReportRoomApiSupportedCallsCountLock.withLock { isReportRoomApiSupportedUnderlyingCallsCount += 1 }
|
|
if let isReportRoomApiSupportedClosure = isReportRoomApiSupportedClosure {
|
|
return try await isReportRoomApiSupportedClosure()
|
|
} else {
|
|
return isReportRoomApiSupportedReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - isRoomAliasAvailable
|
|
|
|
open var isRoomAliasAvailableAliasThrowableError: Error?
|
|
private let isRoomAliasAvailableAliasCallsCountLock = NSLock()
|
|
private var isRoomAliasAvailableAliasUnderlyingCallsCount = 0
|
|
open var isRoomAliasAvailableAliasCallsCount: Int {
|
|
get { isRoomAliasAvailableAliasCallsCountLock.withLock { isRoomAliasAvailableAliasUnderlyingCallsCount } }
|
|
set { isRoomAliasAvailableAliasCallsCountLock.withLock { isRoomAliasAvailableAliasUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var isRoomAliasAvailableAliasCalled: Bool {
|
|
return isRoomAliasAvailableAliasCallsCount > 0
|
|
}
|
|
private let isRoomAliasAvailableAliasReceivedAliasLock = NSLock()
|
|
private var isRoomAliasAvailableAliasUnderlyingReceivedAlias: String?
|
|
open var isRoomAliasAvailableAliasReceivedAlias: String? {
|
|
get { isRoomAliasAvailableAliasReceivedAliasLock.withLock { isRoomAliasAvailableAliasUnderlyingReceivedAlias } }
|
|
set { isRoomAliasAvailableAliasReceivedAliasLock.withLock { isRoomAliasAvailableAliasUnderlyingReceivedAlias = newValue } }
|
|
}
|
|
private let isRoomAliasAvailableAliasReceivedInvocationsLock = NSLock()
|
|
private var isRoomAliasAvailableAliasUnderlyingReceivedInvocations: [String] = []
|
|
open var isRoomAliasAvailableAliasReceivedInvocations: [String] {
|
|
get { isRoomAliasAvailableAliasReceivedInvocationsLock.withLock { isRoomAliasAvailableAliasUnderlyingReceivedInvocations } }
|
|
set { isRoomAliasAvailableAliasReceivedInvocationsLock.withLock { isRoomAliasAvailableAliasUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let isRoomAliasAvailableAliasReturnValueLock = NSLock()
|
|
open var isRoomAliasAvailableAliasUnderlyingReturnValue: Bool!
|
|
open var isRoomAliasAvailableAliasReturnValue: Bool! {
|
|
get { isRoomAliasAvailableAliasReturnValueLock.withLock { isRoomAliasAvailableAliasUnderlyingReturnValue } }
|
|
set { isRoomAliasAvailableAliasReturnValueLock.withLock { isRoomAliasAvailableAliasUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var isRoomAliasAvailableAliasClosure: ((String) async throws -> Bool)?
|
|
|
|
open override func isRoomAliasAvailable(alias: String) async throws -> Bool {
|
|
if let error = isRoomAliasAvailableAliasThrowableError {
|
|
throw error
|
|
}
|
|
isRoomAliasAvailableAliasCallsCountLock.withLock { isRoomAliasAvailableAliasUnderlyingCallsCount += 1 }
|
|
isRoomAliasAvailableAliasReceivedAlias = alias
|
|
isRoomAliasAvailableAliasReceivedInvocationsLock.withLock { isRoomAliasAvailableAliasUnderlyingReceivedInvocations.append(alias) }
|
|
if let isRoomAliasAvailableAliasClosure = isRoomAliasAvailableAliasClosure {
|
|
return try await isRoomAliasAvailableAliasClosure(alias)
|
|
} else {
|
|
return isRoomAliasAvailableAliasReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - joinRoomById
|
|
|
|
open var joinRoomByIdRoomIdThrowableError: Error?
|
|
private let joinRoomByIdRoomIdCallsCountLock = NSLock()
|
|
private var joinRoomByIdRoomIdUnderlyingCallsCount = 0
|
|
open var joinRoomByIdRoomIdCallsCount: Int {
|
|
get { joinRoomByIdRoomIdCallsCountLock.withLock { joinRoomByIdRoomIdUnderlyingCallsCount } }
|
|
set { joinRoomByIdRoomIdCallsCountLock.withLock { joinRoomByIdRoomIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var joinRoomByIdRoomIdCalled: Bool {
|
|
return joinRoomByIdRoomIdCallsCount > 0
|
|
}
|
|
private let joinRoomByIdRoomIdReceivedRoomIdLock = NSLock()
|
|
private var joinRoomByIdRoomIdUnderlyingReceivedRoomId: String?
|
|
open var joinRoomByIdRoomIdReceivedRoomId: String? {
|
|
get { joinRoomByIdRoomIdReceivedRoomIdLock.withLock { joinRoomByIdRoomIdUnderlyingReceivedRoomId } }
|
|
set { joinRoomByIdRoomIdReceivedRoomIdLock.withLock { joinRoomByIdRoomIdUnderlyingReceivedRoomId = newValue } }
|
|
}
|
|
private let joinRoomByIdRoomIdReceivedInvocationsLock = NSLock()
|
|
private var joinRoomByIdRoomIdUnderlyingReceivedInvocations: [String] = []
|
|
open var joinRoomByIdRoomIdReceivedInvocations: [String] {
|
|
get { joinRoomByIdRoomIdReceivedInvocationsLock.withLock { joinRoomByIdRoomIdUnderlyingReceivedInvocations } }
|
|
set { joinRoomByIdRoomIdReceivedInvocationsLock.withLock { joinRoomByIdRoomIdUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let joinRoomByIdRoomIdReturnValueLock = NSLock()
|
|
open var joinRoomByIdRoomIdUnderlyingReturnValue: Room!
|
|
open var joinRoomByIdRoomIdReturnValue: Room! {
|
|
get { joinRoomByIdRoomIdReturnValueLock.withLock { joinRoomByIdRoomIdUnderlyingReturnValue } }
|
|
set { joinRoomByIdRoomIdReturnValueLock.withLock { joinRoomByIdRoomIdUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var joinRoomByIdRoomIdClosure: ((String) async throws -> Room)?
|
|
|
|
open override func joinRoomById(roomId: String) async throws -> Room {
|
|
if let error = joinRoomByIdRoomIdThrowableError {
|
|
throw error
|
|
}
|
|
joinRoomByIdRoomIdCallsCountLock.withLock { joinRoomByIdRoomIdUnderlyingCallsCount += 1 }
|
|
joinRoomByIdRoomIdReceivedRoomId = roomId
|
|
joinRoomByIdRoomIdReceivedInvocationsLock.withLock { joinRoomByIdRoomIdUnderlyingReceivedInvocations.append(roomId) }
|
|
if let joinRoomByIdRoomIdClosure = joinRoomByIdRoomIdClosure {
|
|
return try await joinRoomByIdRoomIdClosure(roomId)
|
|
} else {
|
|
return joinRoomByIdRoomIdReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - joinRoomByIdOrAlias
|
|
|
|
open var joinRoomByIdOrAliasRoomIdOrAliasServerNamesThrowableError: Error?
|
|
private let joinRoomByIdOrAliasRoomIdOrAliasServerNamesCallsCountLock = NSLock()
|
|
private var joinRoomByIdOrAliasRoomIdOrAliasServerNamesUnderlyingCallsCount = 0
|
|
open var joinRoomByIdOrAliasRoomIdOrAliasServerNamesCallsCount: Int {
|
|
get { joinRoomByIdOrAliasRoomIdOrAliasServerNamesCallsCountLock.withLock { joinRoomByIdOrAliasRoomIdOrAliasServerNamesUnderlyingCallsCount } }
|
|
set { joinRoomByIdOrAliasRoomIdOrAliasServerNamesCallsCountLock.withLock { joinRoomByIdOrAliasRoomIdOrAliasServerNamesUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var joinRoomByIdOrAliasRoomIdOrAliasServerNamesCalled: Bool {
|
|
return joinRoomByIdOrAliasRoomIdOrAliasServerNamesCallsCount > 0
|
|
}
|
|
private let joinRoomByIdOrAliasRoomIdOrAliasServerNamesReceivedArgumentsLock = NSLock()
|
|
private var joinRoomByIdOrAliasRoomIdOrAliasServerNamesUnderlyingReceivedArguments: (roomIdOrAlias: String, serverNames: [String])?
|
|
open var joinRoomByIdOrAliasRoomIdOrAliasServerNamesReceivedArguments: (roomIdOrAlias: String, serverNames: [String])? {
|
|
get { joinRoomByIdOrAliasRoomIdOrAliasServerNamesReceivedArgumentsLock.withLock { joinRoomByIdOrAliasRoomIdOrAliasServerNamesUnderlyingReceivedArguments } }
|
|
set { joinRoomByIdOrAliasRoomIdOrAliasServerNamesReceivedArgumentsLock.withLock { joinRoomByIdOrAliasRoomIdOrAliasServerNamesUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let joinRoomByIdOrAliasRoomIdOrAliasServerNamesReceivedInvocationsLock = NSLock()
|
|
private var joinRoomByIdOrAliasRoomIdOrAliasServerNamesUnderlyingReceivedInvocations: [(roomIdOrAlias: String, serverNames: [String])] = []
|
|
open var joinRoomByIdOrAliasRoomIdOrAliasServerNamesReceivedInvocations: [(roomIdOrAlias: String, serverNames: [String])] {
|
|
get { joinRoomByIdOrAliasRoomIdOrAliasServerNamesReceivedInvocationsLock.withLock { joinRoomByIdOrAliasRoomIdOrAliasServerNamesUnderlyingReceivedInvocations } }
|
|
set { joinRoomByIdOrAliasRoomIdOrAliasServerNamesReceivedInvocationsLock.withLock { joinRoomByIdOrAliasRoomIdOrAliasServerNamesUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let joinRoomByIdOrAliasRoomIdOrAliasServerNamesReturnValueLock = NSLock()
|
|
open var joinRoomByIdOrAliasRoomIdOrAliasServerNamesUnderlyingReturnValue: Room!
|
|
open var joinRoomByIdOrAliasRoomIdOrAliasServerNamesReturnValue: Room! {
|
|
get { joinRoomByIdOrAliasRoomIdOrAliasServerNamesReturnValueLock.withLock { joinRoomByIdOrAliasRoomIdOrAliasServerNamesUnderlyingReturnValue } }
|
|
set { joinRoomByIdOrAliasRoomIdOrAliasServerNamesReturnValueLock.withLock { joinRoomByIdOrAliasRoomIdOrAliasServerNamesUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var joinRoomByIdOrAliasRoomIdOrAliasServerNamesClosure: ((String, [String]) async throws -> Room)?
|
|
|
|
open override func joinRoomByIdOrAlias(roomIdOrAlias: String, serverNames: [String]) async throws -> Room {
|
|
if let error = joinRoomByIdOrAliasRoomIdOrAliasServerNamesThrowableError {
|
|
throw error
|
|
}
|
|
joinRoomByIdOrAliasRoomIdOrAliasServerNamesCallsCountLock.withLock { joinRoomByIdOrAliasRoomIdOrAliasServerNamesUnderlyingCallsCount += 1 }
|
|
joinRoomByIdOrAliasRoomIdOrAliasServerNamesReceivedArguments = (roomIdOrAlias: roomIdOrAlias, serverNames: serverNames)
|
|
joinRoomByIdOrAliasRoomIdOrAliasServerNamesReceivedInvocationsLock.withLock { joinRoomByIdOrAliasRoomIdOrAliasServerNamesUnderlyingReceivedInvocations.append((roomIdOrAlias: roomIdOrAlias, serverNames: serverNames)) }
|
|
if let joinRoomByIdOrAliasRoomIdOrAliasServerNamesClosure = joinRoomByIdOrAliasRoomIdOrAliasServerNamesClosure {
|
|
return try await joinRoomByIdOrAliasRoomIdOrAliasServerNamesClosure(roomIdOrAlias, serverNames)
|
|
} else {
|
|
return joinRoomByIdOrAliasRoomIdOrAliasServerNamesReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - knock
|
|
|
|
open var knockRoomIdOrAliasReasonServerNamesThrowableError: Error?
|
|
private let knockRoomIdOrAliasReasonServerNamesCallsCountLock = NSLock()
|
|
private var knockRoomIdOrAliasReasonServerNamesUnderlyingCallsCount = 0
|
|
open var knockRoomIdOrAliasReasonServerNamesCallsCount: Int {
|
|
get { knockRoomIdOrAliasReasonServerNamesCallsCountLock.withLock { knockRoomIdOrAliasReasonServerNamesUnderlyingCallsCount } }
|
|
set { knockRoomIdOrAliasReasonServerNamesCallsCountLock.withLock { knockRoomIdOrAliasReasonServerNamesUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var knockRoomIdOrAliasReasonServerNamesCalled: Bool {
|
|
return knockRoomIdOrAliasReasonServerNamesCallsCount > 0
|
|
}
|
|
private let knockRoomIdOrAliasReasonServerNamesReceivedArgumentsLock = NSLock()
|
|
private var knockRoomIdOrAliasReasonServerNamesUnderlyingReceivedArguments: (roomIdOrAlias: String, reason: String?, serverNames: [String])?
|
|
open var knockRoomIdOrAliasReasonServerNamesReceivedArguments: (roomIdOrAlias: String, reason: String?, serverNames: [String])? {
|
|
get { knockRoomIdOrAliasReasonServerNamesReceivedArgumentsLock.withLock { knockRoomIdOrAliasReasonServerNamesUnderlyingReceivedArguments } }
|
|
set { knockRoomIdOrAliasReasonServerNamesReceivedArgumentsLock.withLock { knockRoomIdOrAliasReasonServerNamesUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let knockRoomIdOrAliasReasonServerNamesReceivedInvocationsLock = NSLock()
|
|
private var knockRoomIdOrAliasReasonServerNamesUnderlyingReceivedInvocations: [(roomIdOrAlias: String, reason: String?, serverNames: [String])] = []
|
|
open var knockRoomIdOrAliasReasonServerNamesReceivedInvocations: [(roomIdOrAlias: String, reason: String?, serverNames: [String])] {
|
|
get { knockRoomIdOrAliasReasonServerNamesReceivedInvocationsLock.withLock { knockRoomIdOrAliasReasonServerNamesUnderlyingReceivedInvocations } }
|
|
set { knockRoomIdOrAliasReasonServerNamesReceivedInvocationsLock.withLock { knockRoomIdOrAliasReasonServerNamesUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let knockRoomIdOrAliasReasonServerNamesReturnValueLock = NSLock()
|
|
open var knockRoomIdOrAliasReasonServerNamesUnderlyingReturnValue: Room!
|
|
open var knockRoomIdOrAliasReasonServerNamesReturnValue: Room! {
|
|
get { knockRoomIdOrAliasReasonServerNamesReturnValueLock.withLock { knockRoomIdOrAliasReasonServerNamesUnderlyingReturnValue } }
|
|
set { knockRoomIdOrAliasReasonServerNamesReturnValueLock.withLock { knockRoomIdOrAliasReasonServerNamesUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var knockRoomIdOrAliasReasonServerNamesClosure: ((String, String?, [String]) async throws -> Room)?
|
|
|
|
open override func knock(roomIdOrAlias: String, reason: String?, serverNames: [String]) async throws -> Room {
|
|
if let error = knockRoomIdOrAliasReasonServerNamesThrowableError {
|
|
throw error
|
|
}
|
|
knockRoomIdOrAliasReasonServerNamesCallsCountLock.withLock { knockRoomIdOrAliasReasonServerNamesUnderlyingCallsCount += 1 }
|
|
knockRoomIdOrAliasReasonServerNamesReceivedArguments = (roomIdOrAlias: roomIdOrAlias, reason: reason, serverNames: serverNames)
|
|
knockRoomIdOrAliasReasonServerNamesReceivedInvocationsLock.withLock { knockRoomIdOrAliasReasonServerNamesUnderlyingReceivedInvocations.append((roomIdOrAlias: roomIdOrAlias, reason: reason, serverNames: serverNames)) }
|
|
if let knockRoomIdOrAliasReasonServerNamesClosure = knockRoomIdOrAliasReasonServerNamesClosure {
|
|
return try await knockRoomIdOrAliasReasonServerNamesClosure(roomIdOrAlias, reason, serverNames)
|
|
} else {
|
|
return knockRoomIdOrAliasReasonServerNamesReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - login
|
|
|
|
open var loginUsernamePasswordInitialDeviceNameDeviceIdThrowableError: Error?
|
|
private let loginUsernamePasswordInitialDeviceNameDeviceIdCallsCountLock = NSLock()
|
|
private var loginUsernamePasswordInitialDeviceNameDeviceIdUnderlyingCallsCount = 0
|
|
open var loginUsernamePasswordInitialDeviceNameDeviceIdCallsCount: Int {
|
|
get { loginUsernamePasswordInitialDeviceNameDeviceIdCallsCountLock.withLock { loginUsernamePasswordInitialDeviceNameDeviceIdUnderlyingCallsCount } }
|
|
set { loginUsernamePasswordInitialDeviceNameDeviceIdCallsCountLock.withLock { loginUsernamePasswordInitialDeviceNameDeviceIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var loginUsernamePasswordInitialDeviceNameDeviceIdCalled: Bool {
|
|
return loginUsernamePasswordInitialDeviceNameDeviceIdCallsCount > 0
|
|
}
|
|
private let loginUsernamePasswordInitialDeviceNameDeviceIdReceivedArgumentsLock = NSLock()
|
|
private var loginUsernamePasswordInitialDeviceNameDeviceIdUnderlyingReceivedArguments: (username: String, password: String, initialDeviceName: String?, deviceId: String?)?
|
|
open var loginUsernamePasswordInitialDeviceNameDeviceIdReceivedArguments: (username: String, password: String, initialDeviceName: String?, deviceId: String?)? {
|
|
get { loginUsernamePasswordInitialDeviceNameDeviceIdReceivedArgumentsLock.withLock { loginUsernamePasswordInitialDeviceNameDeviceIdUnderlyingReceivedArguments } }
|
|
set { loginUsernamePasswordInitialDeviceNameDeviceIdReceivedArgumentsLock.withLock { loginUsernamePasswordInitialDeviceNameDeviceIdUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let loginUsernamePasswordInitialDeviceNameDeviceIdReceivedInvocationsLock = NSLock()
|
|
private var loginUsernamePasswordInitialDeviceNameDeviceIdUnderlyingReceivedInvocations: [(username: String, password: String, initialDeviceName: String?, deviceId: String?)] = []
|
|
open var loginUsernamePasswordInitialDeviceNameDeviceIdReceivedInvocations: [(username: String, password: String, initialDeviceName: String?, deviceId: String?)] {
|
|
get { loginUsernamePasswordInitialDeviceNameDeviceIdReceivedInvocationsLock.withLock { loginUsernamePasswordInitialDeviceNameDeviceIdUnderlyingReceivedInvocations } }
|
|
set { loginUsernamePasswordInitialDeviceNameDeviceIdReceivedInvocationsLock.withLock { loginUsernamePasswordInitialDeviceNameDeviceIdUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var loginUsernamePasswordInitialDeviceNameDeviceIdClosure: ((String, String, String?, String?) async throws -> Void)?
|
|
|
|
open override func login(username: String, password: String, initialDeviceName: String?, deviceId: String?) async throws {
|
|
if let error = loginUsernamePasswordInitialDeviceNameDeviceIdThrowableError {
|
|
throw error
|
|
}
|
|
loginUsernamePasswordInitialDeviceNameDeviceIdCallsCountLock.withLock { loginUsernamePasswordInitialDeviceNameDeviceIdUnderlyingCallsCount += 1 }
|
|
loginUsernamePasswordInitialDeviceNameDeviceIdReceivedArguments = (username: username, password: password, initialDeviceName: initialDeviceName, deviceId: deviceId)
|
|
loginUsernamePasswordInitialDeviceNameDeviceIdReceivedInvocationsLock.withLock { loginUsernamePasswordInitialDeviceNameDeviceIdUnderlyingReceivedInvocations.append((username: username, password: password, initialDeviceName: initialDeviceName, deviceId: deviceId)) }
|
|
try await loginUsernamePasswordInitialDeviceNameDeviceIdClosure?(username, password, initialDeviceName, deviceId)
|
|
}
|
|
|
|
//MARK: - loginWithEmail
|
|
|
|
open var loginWithEmailEmailPasswordInitialDeviceNameDeviceIdThrowableError: Error?
|
|
private let loginWithEmailEmailPasswordInitialDeviceNameDeviceIdCallsCountLock = NSLock()
|
|
private var loginWithEmailEmailPasswordInitialDeviceNameDeviceIdUnderlyingCallsCount = 0
|
|
open var loginWithEmailEmailPasswordInitialDeviceNameDeviceIdCallsCount: Int {
|
|
get { loginWithEmailEmailPasswordInitialDeviceNameDeviceIdCallsCountLock.withLock { loginWithEmailEmailPasswordInitialDeviceNameDeviceIdUnderlyingCallsCount } }
|
|
set { loginWithEmailEmailPasswordInitialDeviceNameDeviceIdCallsCountLock.withLock { loginWithEmailEmailPasswordInitialDeviceNameDeviceIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var loginWithEmailEmailPasswordInitialDeviceNameDeviceIdCalled: Bool {
|
|
return loginWithEmailEmailPasswordInitialDeviceNameDeviceIdCallsCount > 0
|
|
}
|
|
private let loginWithEmailEmailPasswordInitialDeviceNameDeviceIdReceivedArgumentsLock = NSLock()
|
|
private var loginWithEmailEmailPasswordInitialDeviceNameDeviceIdUnderlyingReceivedArguments: (email: String, password: String, initialDeviceName: String?, deviceId: String?)?
|
|
open var loginWithEmailEmailPasswordInitialDeviceNameDeviceIdReceivedArguments: (email: String, password: String, initialDeviceName: String?, deviceId: String?)? {
|
|
get { loginWithEmailEmailPasswordInitialDeviceNameDeviceIdReceivedArgumentsLock.withLock { loginWithEmailEmailPasswordInitialDeviceNameDeviceIdUnderlyingReceivedArguments } }
|
|
set { loginWithEmailEmailPasswordInitialDeviceNameDeviceIdReceivedArgumentsLock.withLock { loginWithEmailEmailPasswordInitialDeviceNameDeviceIdUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let loginWithEmailEmailPasswordInitialDeviceNameDeviceIdReceivedInvocationsLock = NSLock()
|
|
private var loginWithEmailEmailPasswordInitialDeviceNameDeviceIdUnderlyingReceivedInvocations: [(email: String, password: String, initialDeviceName: String?, deviceId: String?)] = []
|
|
open var loginWithEmailEmailPasswordInitialDeviceNameDeviceIdReceivedInvocations: [(email: String, password: String, initialDeviceName: String?, deviceId: String?)] {
|
|
get { loginWithEmailEmailPasswordInitialDeviceNameDeviceIdReceivedInvocationsLock.withLock { loginWithEmailEmailPasswordInitialDeviceNameDeviceIdUnderlyingReceivedInvocations } }
|
|
set { loginWithEmailEmailPasswordInitialDeviceNameDeviceIdReceivedInvocationsLock.withLock { loginWithEmailEmailPasswordInitialDeviceNameDeviceIdUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var loginWithEmailEmailPasswordInitialDeviceNameDeviceIdClosure: ((String, String, String?, String?) async throws -> Void)?
|
|
|
|
open override func loginWithEmail(email: String, password: String, initialDeviceName: String?, deviceId: String?) async throws {
|
|
if let error = loginWithEmailEmailPasswordInitialDeviceNameDeviceIdThrowableError {
|
|
throw error
|
|
}
|
|
loginWithEmailEmailPasswordInitialDeviceNameDeviceIdCallsCountLock.withLock { loginWithEmailEmailPasswordInitialDeviceNameDeviceIdUnderlyingCallsCount += 1 }
|
|
loginWithEmailEmailPasswordInitialDeviceNameDeviceIdReceivedArguments = (email: email, password: password, initialDeviceName: initialDeviceName, deviceId: deviceId)
|
|
loginWithEmailEmailPasswordInitialDeviceNameDeviceIdReceivedInvocationsLock.withLock { loginWithEmailEmailPasswordInitialDeviceNameDeviceIdUnderlyingReceivedInvocations.append((email: email, password: password, initialDeviceName: initialDeviceName, deviceId: deviceId)) }
|
|
try await loginWithEmailEmailPasswordInitialDeviceNameDeviceIdClosure?(email, password, initialDeviceName, deviceId)
|
|
}
|
|
|
|
//MARK: - loginWithOauthCallback
|
|
|
|
open var loginWithOauthCallbackCallbackUrlThrowableError: Error?
|
|
private let loginWithOauthCallbackCallbackUrlCallsCountLock = NSLock()
|
|
private var loginWithOauthCallbackCallbackUrlUnderlyingCallsCount = 0
|
|
open var loginWithOauthCallbackCallbackUrlCallsCount: Int {
|
|
get { loginWithOauthCallbackCallbackUrlCallsCountLock.withLock { loginWithOauthCallbackCallbackUrlUnderlyingCallsCount } }
|
|
set { loginWithOauthCallbackCallbackUrlCallsCountLock.withLock { loginWithOauthCallbackCallbackUrlUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var loginWithOauthCallbackCallbackUrlCalled: Bool {
|
|
return loginWithOauthCallbackCallbackUrlCallsCount > 0
|
|
}
|
|
private let loginWithOauthCallbackCallbackUrlReceivedCallbackUrlLock = NSLock()
|
|
private var loginWithOauthCallbackCallbackUrlUnderlyingReceivedCallbackUrl: String?
|
|
open var loginWithOauthCallbackCallbackUrlReceivedCallbackUrl: String? {
|
|
get { loginWithOauthCallbackCallbackUrlReceivedCallbackUrlLock.withLock { loginWithOauthCallbackCallbackUrlUnderlyingReceivedCallbackUrl } }
|
|
set { loginWithOauthCallbackCallbackUrlReceivedCallbackUrlLock.withLock { loginWithOauthCallbackCallbackUrlUnderlyingReceivedCallbackUrl = newValue } }
|
|
}
|
|
private let loginWithOauthCallbackCallbackUrlReceivedInvocationsLock = NSLock()
|
|
private var loginWithOauthCallbackCallbackUrlUnderlyingReceivedInvocations: [String] = []
|
|
open var loginWithOauthCallbackCallbackUrlReceivedInvocations: [String] {
|
|
get { loginWithOauthCallbackCallbackUrlReceivedInvocationsLock.withLock { loginWithOauthCallbackCallbackUrlUnderlyingReceivedInvocations } }
|
|
set { loginWithOauthCallbackCallbackUrlReceivedInvocationsLock.withLock { loginWithOauthCallbackCallbackUrlUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var loginWithOauthCallbackCallbackUrlClosure: ((String) async throws -> Void)?
|
|
|
|
open override func loginWithOauthCallback(callbackUrl: String) async throws {
|
|
if let error = loginWithOauthCallbackCallbackUrlThrowableError {
|
|
throw error
|
|
}
|
|
loginWithOauthCallbackCallbackUrlCallsCountLock.withLock { loginWithOauthCallbackCallbackUrlUnderlyingCallsCount += 1 }
|
|
loginWithOauthCallbackCallbackUrlReceivedCallbackUrl = callbackUrl
|
|
loginWithOauthCallbackCallbackUrlReceivedInvocationsLock.withLock { loginWithOauthCallbackCallbackUrlUnderlyingReceivedInvocations.append(callbackUrl) }
|
|
try await loginWithOauthCallbackCallbackUrlClosure?(callbackUrl)
|
|
}
|
|
|
|
//MARK: - logout
|
|
|
|
open var logoutThrowableError: Error?
|
|
private let logoutCallsCountLock = NSLock()
|
|
private var logoutUnderlyingCallsCount = 0
|
|
open var logoutCallsCount: Int {
|
|
get { logoutCallsCountLock.withLock { logoutUnderlyingCallsCount } }
|
|
set { logoutCallsCountLock.withLock { logoutUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var logoutCalled: Bool {
|
|
return logoutCallsCount > 0
|
|
}
|
|
open var logoutClosure: (() async throws -> Void)?
|
|
|
|
open override func logout() async throws {
|
|
if let error = logoutThrowableError {
|
|
throw error
|
|
}
|
|
logoutCallsCountLock.withLock { logoutUnderlyingCallsCount += 1 }
|
|
try await logoutClosure?()
|
|
}
|
|
|
|
//MARK: - markAllRoomsAsRead
|
|
|
|
open var markAllRoomsAsReadThrowableError: Error?
|
|
private let markAllRoomsAsReadCallsCountLock = NSLock()
|
|
private var markAllRoomsAsReadUnderlyingCallsCount = 0
|
|
open var markAllRoomsAsReadCallsCount: Int {
|
|
get { markAllRoomsAsReadCallsCountLock.withLock { markAllRoomsAsReadUnderlyingCallsCount } }
|
|
set { markAllRoomsAsReadCallsCountLock.withLock { markAllRoomsAsReadUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var markAllRoomsAsReadCalled: Bool {
|
|
return markAllRoomsAsReadCallsCount > 0
|
|
}
|
|
open var markAllRoomsAsReadClosure: (() async throws -> Void)?
|
|
|
|
open override func markAllRoomsAsRead() async throws {
|
|
if let error = markAllRoomsAsReadThrowableError {
|
|
throw error
|
|
}
|
|
markAllRoomsAsReadCallsCountLock.withLock { markAllRoomsAsReadUnderlyingCallsCount += 1 }
|
|
try await markAllRoomsAsReadClosure?()
|
|
}
|
|
|
|
//MARK: - newGrantLoginWithQrCodeHandler
|
|
|
|
private let newGrantLoginWithQrCodeHandlerCallsCountLock = NSLock()
|
|
private var newGrantLoginWithQrCodeHandlerUnderlyingCallsCount = 0
|
|
open var newGrantLoginWithQrCodeHandlerCallsCount: Int {
|
|
get { newGrantLoginWithQrCodeHandlerCallsCountLock.withLock { newGrantLoginWithQrCodeHandlerUnderlyingCallsCount } }
|
|
set { newGrantLoginWithQrCodeHandlerCallsCountLock.withLock { newGrantLoginWithQrCodeHandlerUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var newGrantLoginWithQrCodeHandlerCalled: Bool {
|
|
return newGrantLoginWithQrCodeHandlerCallsCount > 0
|
|
}
|
|
|
|
private let newGrantLoginWithQrCodeHandlerReturnValueLock = NSLock()
|
|
open var newGrantLoginWithQrCodeHandlerUnderlyingReturnValue: GrantLoginWithQrCodeHandler!
|
|
open var newGrantLoginWithQrCodeHandlerReturnValue: GrantLoginWithQrCodeHandler! {
|
|
get { newGrantLoginWithQrCodeHandlerReturnValueLock.withLock { newGrantLoginWithQrCodeHandlerUnderlyingReturnValue } }
|
|
set { newGrantLoginWithQrCodeHandlerReturnValueLock.withLock { newGrantLoginWithQrCodeHandlerUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var newGrantLoginWithQrCodeHandlerClosure: (() -> GrantLoginWithQrCodeHandler)?
|
|
|
|
open override func newGrantLoginWithQrCodeHandler() -> GrantLoginWithQrCodeHandler {
|
|
newGrantLoginWithQrCodeHandlerCallsCountLock.withLock { newGrantLoginWithQrCodeHandlerUnderlyingCallsCount += 1 }
|
|
if let newGrantLoginWithQrCodeHandlerClosure = newGrantLoginWithQrCodeHandlerClosure {
|
|
return newGrantLoginWithQrCodeHandlerClosure()
|
|
} else {
|
|
return newGrantLoginWithQrCodeHandlerReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - newLoginWithQrCodeHandler
|
|
|
|
private let newLoginWithQrCodeHandlerOauthConfigurationCallsCountLock = NSLock()
|
|
private var newLoginWithQrCodeHandlerOauthConfigurationUnderlyingCallsCount = 0
|
|
open var newLoginWithQrCodeHandlerOauthConfigurationCallsCount: Int {
|
|
get { newLoginWithQrCodeHandlerOauthConfigurationCallsCountLock.withLock { newLoginWithQrCodeHandlerOauthConfigurationUnderlyingCallsCount } }
|
|
set { newLoginWithQrCodeHandlerOauthConfigurationCallsCountLock.withLock { newLoginWithQrCodeHandlerOauthConfigurationUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var newLoginWithQrCodeHandlerOauthConfigurationCalled: Bool {
|
|
return newLoginWithQrCodeHandlerOauthConfigurationCallsCount > 0
|
|
}
|
|
private let newLoginWithQrCodeHandlerOauthConfigurationReceivedOauthConfigurationLock = NSLock()
|
|
private var newLoginWithQrCodeHandlerOauthConfigurationUnderlyingReceivedOauthConfiguration: OAuthConfiguration?
|
|
open var newLoginWithQrCodeHandlerOauthConfigurationReceivedOauthConfiguration: OAuthConfiguration? {
|
|
get { newLoginWithQrCodeHandlerOauthConfigurationReceivedOauthConfigurationLock.withLock { newLoginWithQrCodeHandlerOauthConfigurationUnderlyingReceivedOauthConfiguration } }
|
|
set { newLoginWithQrCodeHandlerOauthConfigurationReceivedOauthConfigurationLock.withLock { newLoginWithQrCodeHandlerOauthConfigurationUnderlyingReceivedOauthConfiguration = newValue } }
|
|
}
|
|
private let newLoginWithQrCodeHandlerOauthConfigurationReceivedInvocationsLock = NSLock()
|
|
private var newLoginWithQrCodeHandlerOauthConfigurationUnderlyingReceivedInvocations: [OAuthConfiguration] = []
|
|
open var newLoginWithQrCodeHandlerOauthConfigurationReceivedInvocations: [OAuthConfiguration] {
|
|
get { newLoginWithQrCodeHandlerOauthConfigurationReceivedInvocationsLock.withLock { newLoginWithQrCodeHandlerOauthConfigurationUnderlyingReceivedInvocations } }
|
|
set { newLoginWithQrCodeHandlerOauthConfigurationReceivedInvocationsLock.withLock { newLoginWithQrCodeHandlerOauthConfigurationUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let newLoginWithQrCodeHandlerOauthConfigurationReturnValueLock = NSLock()
|
|
open var newLoginWithQrCodeHandlerOauthConfigurationUnderlyingReturnValue: LoginWithQrCodeHandler!
|
|
open var newLoginWithQrCodeHandlerOauthConfigurationReturnValue: LoginWithQrCodeHandler! {
|
|
get { newLoginWithQrCodeHandlerOauthConfigurationReturnValueLock.withLock { newLoginWithQrCodeHandlerOauthConfigurationUnderlyingReturnValue } }
|
|
set { newLoginWithQrCodeHandlerOauthConfigurationReturnValueLock.withLock { newLoginWithQrCodeHandlerOauthConfigurationUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var newLoginWithQrCodeHandlerOauthConfigurationClosure: ((OAuthConfiguration) -> LoginWithQrCodeHandler)?
|
|
|
|
open override func newLoginWithQrCodeHandler(oauthConfiguration: OAuthConfiguration) -> LoginWithQrCodeHandler {
|
|
newLoginWithQrCodeHandlerOauthConfigurationCallsCountLock.withLock { newLoginWithQrCodeHandlerOauthConfigurationUnderlyingCallsCount += 1 }
|
|
newLoginWithQrCodeHandlerOauthConfigurationReceivedOauthConfiguration = oauthConfiguration
|
|
newLoginWithQrCodeHandlerOauthConfigurationReceivedInvocationsLock.withLock { newLoginWithQrCodeHandlerOauthConfigurationUnderlyingReceivedInvocations.append(oauthConfiguration) }
|
|
if let newLoginWithQrCodeHandlerOauthConfigurationClosure = newLoginWithQrCodeHandlerOauthConfigurationClosure {
|
|
return newLoginWithQrCodeHandlerOauthConfigurationClosure(oauthConfiguration)
|
|
} else {
|
|
return newLoginWithQrCodeHandlerOauthConfigurationReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - notificationClient
|
|
|
|
open var notificationClientProcessSetupThrowableError: Error?
|
|
private let notificationClientProcessSetupCallsCountLock = NSLock()
|
|
private var notificationClientProcessSetupUnderlyingCallsCount = 0
|
|
open var notificationClientProcessSetupCallsCount: Int {
|
|
get { notificationClientProcessSetupCallsCountLock.withLock { notificationClientProcessSetupUnderlyingCallsCount } }
|
|
set { notificationClientProcessSetupCallsCountLock.withLock { notificationClientProcessSetupUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var notificationClientProcessSetupCalled: Bool {
|
|
return notificationClientProcessSetupCallsCount > 0
|
|
}
|
|
private let notificationClientProcessSetupReceivedProcessSetupLock = NSLock()
|
|
private var notificationClientProcessSetupUnderlyingReceivedProcessSetup: NotificationProcessSetup?
|
|
open var notificationClientProcessSetupReceivedProcessSetup: NotificationProcessSetup? {
|
|
get { notificationClientProcessSetupReceivedProcessSetupLock.withLock { notificationClientProcessSetupUnderlyingReceivedProcessSetup } }
|
|
set { notificationClientProcessSetupReceivedProcessSetupLock.withLock { notificationClientProcessSetupUnderlyingReceivedProcessSetup = newValue } }
|
|
}
|
|
private let notificationClientProcessSetupReceivedInvocationsLock = NSLock()
|
|
private var notificationClientProcessSetupUnderlyingReceivedInvocations: [NotificationProcessSetup] = []
|
|
open var notificationClientProcessSetupReceivedInvocations: [NotificationProcessSetup] {
|
|
get { notificationClientProcessSetupReceivedInvocationsLock.withLock { notificationClientProcessSetupUnderlyingReceivedInvocations } }
|
|
set { notificationClientProcessSetupReceivedInvocationsLock.withLock { notificationClientProcessSetupUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let notificationClientProcessSetupReturnValueLock = NSLock()
|
|
open var notificationClientProcessSetupUnderlyingReturnValue: NotificationClient!
|
|
open var notificationClientProcessSetupReturnValue: NotificationClient! {
|
|
get { notificationClientProcessSetupReturnValueLock.withLock { notificationClientProcessSetupUnderlyingReturnValue } }
|
|
set { notificationClientProcessSetupReturnValueLock.withLock { notificationClientProcessSetupUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var notificationClientProcessSetupClosure: ((NotificationProcessSetup) async throws -> NotificationClient)?
|
|
|
|
open override func notificationClient(processSetup: NotificationProcessSetup) async throws -> NotificationClient {
|
|
if let error = notificationClientProcessSetupThrowableError {
|
|
throw error
|
|
}
|
|
notificationClientProcessSetupCallsCountLock.withLock { notificationClientProcessSetupUnderlyingCallsCount += 1 }
|
|
notificationClientProcessSetupReceivedProcessSetup = processSetup
|
|
notificationClientProcessSetupReceivedInvocationsLock.withLock { notificationClientProcessSetupUnderlyingReceivedInvocations.append(processSetup) }
|
|
if let notificationClientProcessSetupClosure = notificationClientProcessSetupClosure {
|
|
return try await notificationClientProcessSetupClosure(processSetup)
|
|
} else {
|
|
return notificationClientProcessSetupReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - observeAccountDataEvent
|
|
|
|
private let observeAccountDataEventEventTypeListenerCallsCountLock = NSLock()
|
|
private var observeAccountDataEventEventTypeListenerUnderlyingCallsCount = 0
|
|
open var observeAccountDataEventEventTypeListenerCallsCount: Int {
|
|
get { observeAccountDataEventEventTypeListenerCallsCountLock.withLock { observeAccountDataEventEventTypeListenerUnderlyingCallsCount } }
|
|
set { observeAccountDataEventEventTypeListenerCallsCountLock.withLock { observeAccountDataEventEventTypeListenerUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var observeAccountDataEventEventTypeListenerCalled: Bool {
|
|
return observeAccountDataEventEventTypeListenerCallsCount > 0
|
|
}
|
|
private let observeAccountDataEventEventTypeListenerReceivedArgumentsLock = NSLock()
|
|
private var observeAccountDataEventEventTypeListenerUnderlyingReceivedArguments: (eventType: AccountDataEventType, listener: AccountDataListener)?
|
|
open var observeAccountDataEventEventTypeListenerReceivedArguments: (eventType: AccountDataEventType, listener: AccountDataListener)? {
|
|
get { observeAccountDataEventEventTypeListenerReceivedArgumentsLock.withLock { observeAccountDataEventEventTypeListenerUnderlyingReceivedArguments } }
|
|
set { observeAccountDataEventEventTypeListenerReceivedArgumentsLock.withLock { observeAccountDataEventEventTypeListenerUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let observeAccountDataEventEventTypeListenerReceivedInvocationsLock = NSLock()
|
|
private var observeAccountDataEventEventTypeListenerUnderlyingReceivedInvocations: [(eventType: AccountDataEventType, listener: AccountDataListener)] = []
|
|
open var observeAccountDataEventEventTypeListenerReceivedInvocations: [(eventType: AccountDataEventType, listener: AccountDataListener)] {
|
|
get { observeAccountDataEventEventTypeListenerReceivedInvocationsLock.withLock { observeAccountDataEventEventTypeListenerUnderlyingReceivedInvocations } }
|
|
set { observeAccountDataEventEventTypeListenerReceivedInvocationsLock.withLock { observeAccountDataEventEventTypeListenerUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let observeAccountDataEventEventTypeListenerReturnValueLock = NSLock()
|
|
open var observeAccountDataEventEventTypeListenerUnderlyingReturnValue: TaskHandle!
|
|
open var observeAccountDataEventEventTypeListenerReturnValue: TaskHandle! {
|
|
get { observeAccountDataEventEventTypeListenerReturnValueLock.withLock { observeAccountDataEventEventTypeListenerUnderlyingReturnValue } }
|
|
set { observeAccountDataEventEventTypeListenerReturnValueLock.withLock { observeAccountDataEventEventTypeListenerUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var observeAccountDataEventEventTypeListenerClosure: ((AccountDataEventType, AccountDataListener) -> TaskHandle)?
|
|
|
|
open override func observeAccountDataEvent(eventType: AccountDataEventType, listener: AccountDataListener) -> TaskHandle {
|
|
observeAccountDataEventEventTypeListenerCallsCountLock.withLock { observeAccountDataEventEventTypeListenerUnderlyingCallsCount += 1 }
|
|
observeAccountDataEventEventTypeListenerReceivedArguments = (eventType: eventType, listener: listener)
|
|
observeAccountDataEventEventTypeListenerReceivedInvocationsLock.withLock { observeAccountDataEventEventTypeListenerUnderlyingReceivedInvocations.append((eventType: eventType, listener: listener)) }
|
|
if let observeAccountDataEventEventTypeListenerClosure = observeAccountDataEventEventTypeListenerClosure {
|
|
return observeAccountDataEventEventTypeListenerClosure(eventType, listener)
|
|
} else {
|
|
return observeAccountDataEventEventTypeListenerReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - observeRoomAccountDataEvent
|
|
|
|
open var observeRoomAccountDataEventRoomIdEventTypeListenerThrowableError: Error?
|
|
private let observeRoomAccountDataEventRoomIdEventTypeListenerCallsCountLock = NSLock()
|
|
private var observeRoomAccountDataEventRoomIdEventTypeListenerUnderlyingCallsCount = 0
|
|
open var observeRoomAccountDataEventRoomIdEventTypeListenerCallsCount: Int {
|
|
get { observeRoomAccountDataEventRoomIdEventTypeListenerCallsCountLock.withLock { observeRoomAccountDataEventRoomIdEventTypeListenerUnderlyingCallsCount } }
|
|
set { observeRoomAccountDataEventRoomIdEventTypeListenerCallsCountLock.withLock { observeRoomAccountDataEventRoomIdEventTypeListenerUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var observeRoomAccountDataEventRoomIdEventTypeListenerCalled: Bool {
|
|
return observeRoomAccountDataEventRoomIdEventTypeListenerCallsCount > 0
|
|
}
|
|
private let observeRoomAccountDataEventRoomIdEventTypeListenerReceivedArgumentsLock = NSLock()
|
|
private var observeRoomAccountDataEventRoomIdEventTypeListenerUnderlyingReceivedArguments: (roomId: String, eventType: RoomAccountDataEventType, listener: RoomAccountDataListener)?
|
|
open var observeRoomAccountDataEventRoomIdEventTypeListenerReceivedArguments: (roomId: String, eventType: RoomAccountDataEventType, listener: RoomAccountDataListener)? {
|
|
get { observeRoomAccountDataEventRoomIdEventTypeListenerReceivedArgumentsLock.withLock { observeRoomAccountDataEventRoomIdEventTypeListenerUnderlyingReceivedArguments } }
|
|
set { observeRoomAccountDataEventRoomIdEventTypeListenerReceivedArgumentsLock.withLock { observeRoomAccountDataEventRoomIdEventTypeListenerUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let observeRoomAccountDataEventRoomIdEventTypeListenerReceivedInvocationsLock = NSLock()
|
|
private var observeRoomAccountDataEventRoomIdEventTypeListenerUnderlyingReceivedInvocations: [(roomId: String, eventType: RoomAccountDataEventType, listener: RoomAccountDataListener)] = []
|
|
open var observeRoomAccountDataEventRoomIdEventTypeListenerReceivedInvocations: [(roomId: String, eventType: RoomAccountDataEventType, listener: RoomAccountDataListener)] {
|
|
get { observeRoomAccountDataEventRoomIdEventTypeListenerReceivedInvocationsLock.withLock { observeRoomAccountDataEventRoomIdEventTypeListenerUnderlyingReceivedInvocations } }
|
|
set { observeRoomAccountDataEventRoomIdEventTypeListenerReceivedInvocationsLock.withLock { observeRoomAccountDataEventRoomIdEventTypeListenerUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let observeRoomAccountDataEventRoomIdEventTypeListenerReturnValueLock = NSLock()
|
|
open var observeRoomAccountDataEventRoomIdEventTypeListenerUnderlyingReturnValue: TaskHandle!
|
|
open var observeRoomAccountDataEventRoomIdEventTypeListenerReturnValue: TaskHandle! {
|
|
get { observeRoomAccountDataEventRoomIdEventTypeListenerReturnValueLock.withLock { observeRoomAccountDataEventRoomIdEventTypeListenerUnderlyingReturnValue } }
|
|
set { observeRoomAccountDataEventRoomIdEventTypeListenerReturnValueLock.withLock { observeRoomAccountDataEventRoomIdEventTypeListenerUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var observeRoomAccountDataEventRoomIdEventTypeListenerClosure: ((String, RoomAccountDataEventType, RoomAccountDataListener) throws -> TaskHandle)?
|
|
|
|
open override func observeRoomAccountDataEvent(roomId: String, eventType: RoomAccountDataEventType, listener: RoomAccountDataListener) throws -> TaskHandle {
|
|
if let error = observeRoomAccountDataEventRoomIdEventTypeListenerThrowableError {
|
|
throw error
|
|
}
|
|
observeRoomAccountDataEventRoomIdEventTypeListenerCallsCountLock.withLock { observeRoomAccountDataEventRoomIdEventTypeListenerUnderlyingCallsCount += 1 }
|
|
observeRoomAccountDataEventRoomIdEventTypeListenerReceivedArguments = (roomId: roomId, eventType: eventType, listener: listener)
|
|
observeRoomAccountDataEventRoomIdEventTypeListenerReceivedInvocationsLock.withLock { observeRoomAccountDataEventRoomIdEventTypeListenerUnderlyingReceivedInvocations.append((roomId: roomId, eventType: eventType, listener: listener)) }
|
|
if let observeRoomAccountDataEventRoomIdEventTypeListenerClosure = observeRoomAccountDataEventRoomIdEventTypeListenerClosure {
|
|
return try observeRoomAccountDataEventRoomIdEventTypeListenerClosure(roomId, eventType, listener)
|
|
} else {
|
|
return observeRoomAccountDataEventRoomIdEventTypeListenerReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - optimizeStores
|
|
|
|
open var optimizeStoresThrowableError: Error?
|
|
private let optimizeStoresCallsCountLock = NSLock()
|
|
private var optimizeStoresUnderlyingCallsCount = 0
|
|
open var optimizeStoresCallsCount: Int {
|
|
get { optimizeStoresCallsCountLock.withLock { optimizeStoresUnderlyingCallsCount } }
|
|
set { optimizeStoresCallsCountLock.withLock { optimizeStoresUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var optimizeStoresCalled: Bool {
|
|
return optimizeStoresCallsCount > 0
|
|
}
|
|
open var optimizeStoresClosure: (() async throws -> Void)?
|
|
|
|
open override func optimizeStores() async throws {
|
|
if let error = optimizeStoresThrowableError {
|
|
throw error
|
|
}
|
|
optimizeStoresCallsCountLock.withLock { optimizeStoresUnderlyingCallsCount += 1 }
|
|
try await optimizeStoresClosure?()
|
|
}
|
|
|
|
//MARK: - pause
|
|
|
|
open var pauseThrowableError: Error?
|
|
private let pauseCallsCountLock = NSLock()
|
|
private var pauseUnderlyingCallsCount = 0
|
|
open var pauseCallsCount: Int {
|
|
get { pauseCallsCountLock.withLock { pauseUnderlyingCallsCount } }
|
|
set { pauseCallsCountLock.withLock { pauseUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var pauseCalled: Bool {
|
|
return pauseCallsCount > 0
|
|
}
|
|
open var pauseClosure: (() async throws -> Void)?
|
|
|
|
open override func pause() async throws {
|
|
if let error = pauseThrowableError {
|
|
throw error
|
|
}
|
|
pauseCallsCountLock.withLock { pauseUnderlyingCallsCount += 1 }
|
|
try await pauseClosure?()
|
|
}
|
|
|
|
//MARK: - registerNotificationHandler
|
|
|
|
private let registerNotificationHandlerListenerCallsCountLock = NSLock()
|
|
private var registerNotificationHandlerListenerUnderlyingCallsCount = 0
|
|
open var registerNotificationHandlerListenerCallsCount: Int {
|
|
get { registerNotificationHandlerListenerCallsCountLock.withLock { registerNotificationHandlerListenerUnderlyingCallsCount } }
|
|
set { registerNotificationHandlerListenerCallsCountLock.withLock { registerNotificationHandlerListenerUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var registerNotificationHandlerListenerCalled: Bool {
|
|
return registerNotificationHandlerListenerCallsCount > 0
|
|
}
|
|
private let registerNotificationHandlerListenerReceivedListenerLock = NSLock()
|
|
private var registerNotificationHandlerListenerUnderlyingReceivedListener: SyncNotificationListener?
|
|
open var registerNotificationHandlerListenerReceivedListener: SyncNotificationListener? {
|
|
get { registerNotificationHandlerListenerReceivedListenerLock.withLock { registerNotificationHandlerListenerUnderlyingReceivedListener } }
|
|
set { registerNotificationHandlerListenerReceivedListenerLock.withLock { registerNotificationHandlerListenerUnderlyingReceivedListener = newValue } }
|
|
}
|
|
private let registerNotificationHandlerListenerReceivedInvocationsLock = NSLock()
|
|
private var registerNotificationHandlerListenerUnderlyingReceivedInvocations: [SyncNotificationListener] = []
|
|
open var registerNotificationHandlerListenerReceivedInvocations: [SyncNotificationListener] {
|
|
get { registerNotificationHandlerListenerReceivedInvocationsLock.withLock { registerNotificationHandlerListenerUnderlyingReceivedInvocations } }
|
|
set { registerNotificationHandlerListenerReceivedInvocationsLock.withLock { registerNotificationHandlerListenerUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var registerNotificationHandlerListenerClosure: ((SyncNotificationListener) async -> Void)?
|
|
|
|
open override func registerNotificationHandler(listener: SyncNotificationListener) async {
|
|
registerNotificationHandlerListenerCallsCountLock.withLock { registerNotificationHandlerListenerUnderlyingCallsCount += 1 }
|
|
registerNotificationHandlerListenerReceivedListener = listener
|
|
registerNotificationHandlerListenerReceivedInvocationsLock.withLock { registerNotificationHandlerListenerUnderlyingReceivedInvocations.append(listener) }
|
|
await registerNotificationHandlerListenerClosure?(listener)
|
|
}
|
|
|
|
//MARK: - removeAvatar
|
|
|
|
open var removeAvatarThrowableError: Error?
|
|
private let removeAvatarCallsCountLock = NSLock()
|
|
private var removeAvatarUnderlyingCallsCount = 0
|
|
open var removeAvatarCallsCount: Int {
|
|
get { removeAvatarCallsCountLock.withLock { removeAvatarUnderlyingCallsCount } }
|
|
set { removeAvatarCallsCountLock.withLock { removeAvatarUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var removeAvatarCalled: Bool {
|
|
return removeAvatarCallsCount > 0
|
|
}
|
|
open var removeAvatarClosure: (() async throws -> Void)?
|
|
|
|
open override func removeAvatar() async throws {
|
|
if let error = removeAvatarThrowableError {
|
|
throw error
|
|
}
|
|
removeAvatarCallsCountLock.withLock { removeAvatarUnderlyingCallsCount += 1 }
|
|
try await removeAvatarClosure?()
|
|
}
|
|
|
|
//MARK: - requestOpenidToken
|
|
|
|
open var requestOpenidTokenThrowableError: Error?
|
|
private let requestOpenidTokenCallsCountLock = NSLock()
|
|
private var requestOpenidTokenUnderlyingCallsCount = 0
|
|
open var requestOpenidTokenCallsCount: Int {
|
|
get { requestOpenidTokenCallsCountLock.withLock { requestOpenidTokenUnderlyingCallsCount } }
|
|
set { requestOpenidTokenCallsCountLock.withLock { requestOpenidTokenUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var requestOpenidTokenCalled: Bool {
|
|
return requestOpenidTokenCallsCount > 0
|
|
}
|
|
|
|
private let requestOpenidTokenReturnValueLock = NSLock()
|
|
open var requestOpenidTokenUnderlyingReturnValue: OpenIdToken!
|
|
open var requestOpenidTokenReturnValue: OpenIdToken! {
|
|
get { requestOpenidTokenReturnValueLock.withLock { requestOpenidTokenUnderlyingReturnValue } }
|
|
set { requestOpenidTokenReturnValueLock.withLock { requestOpenidTokenUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var requestOpenidTokenClosure: (() async throws -> OpenIdToken)?
|
|
|
|
open override func requestOpenidToken() async throws -> OpenIdToken {
|
|
if let error = requestOpenidTokenThrowableError {
|
|
throw error
|
|
}
|
|
requestOpenidTokenCallsCountLock.withLock { requestOpenidTokenUnderlyingCallsCount += 1 }
|
|
if let requestOpenidTokenClosure = requestOpenidTokenClosure {
|
|
return try await requestOpenidTokenClosure()
|
|
} else {
|
|
return requestOpenidTokenReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - resetSupportedVersions
|
|
|
|
open var resetSupportedVersionsThrowableError: Error?
|
|
private let resetSupportedVersionsCallsCountLock = NSLock()
|
|
private var resetSupportedVersionsUnderlyingCallsCount = 0
|
|
open var resetSupportedVersionsCallsCount: Int {
|
|
get { resetSupportedVersionsCallsCountLock.withLock { resetSupportedVersionsUnderlyingCallsCount } }
|
|
set { resetSupportedVersionsCallsCountLock.withLock { resetSupportedVersionsUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var resetSupportedVersionsCalled: Bool {
|
|
return resetSupportedVersionsCallsCount > 0
|
|
}
|
|
open var resetSupportedVersionsClosure: (() async throws -> Void)?
|
|
|
|
open override func resetSupportedVersions() async throws {
|
|
if let error = resetSupportedVersionsThrowableError {
|
|
throw error
|
|
}
|
|
resetSupportedVersionsCallsCountLock.withLock { resetSupportedVersionsUnderlyingCallsCount += 1 }
|
|
try await resetSupportedVersionsClosure?()
|
|
}
|
|
|
|
//MARK: - resetWellKnown
|
|
|
|
open var resetWellKnownThrowableError: Error?
|
|
private let resetWellKnownCallsCountLock = NSLock()
|
|
private var resetWellKnownUnderlyingCallsCount = 0
|
|
open var resetWellKnownCallsCount: Int {
|
|
get { resetWellKnownCallsCountLock.withLock { resetWellKnownUnderlyingCallsCount } }
|
|
set { resetWellKnownCallsCountLock.withLock { resetWellKnownUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var resetWellKnownCalled: Bool {
|
|
return resetWellKnownCallsCount > 0
|
|
}
|
|
open var resetWellKnownClosure: (() async throws -> Void)?
|
|
|
|
open override func resetWellKnown() async throws {
|
|
if let error = resetWellKnownThrowableError {
|
|
throw error
|
|
}
|
|
resetWellKnownCallsCountLock.withLock { resetWellKnownUnderlyingCallsCount += 1 }
|
|
try await resetWellKnownClosure?()
|
|
}
|
|
|
|
//MARK: - resolveRoomAlias
|
|
|
|
open var resolveRoomAliasRoomAliasThrowableError: Error?
|
|
private let resolveRoomAliasRoomAliasCallsCountLock = NSLock()
|
|
private var resolveRoomAliasRoomAliasUnderlyingCallsCount = 0
|
|
open var resolveRoomAliasRoomAliasCallsCount: Int {
|
|
get { resolveRoomAliasRoomAliasCallsCountLock.withLock { resolveRoomAliasRoomAliasUnderlyingCallsCount } }
|
|
set { resolveRoomAliasRoomAliasCallsCountLock.withLock { resolveRoomAliasRoomAliasUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var resolveRoomAliasRoomAliasCalled: Bool {
|
|
return resolveRoomAliasRoomAliasCallsCount > 0
|
|
}
|
|
private let resolveRoomAliasRoomAliasReceivedRoomAliasLock = NSLock()
|
|
private var resolveRoomAliasRoomAliasUnderlyingReceivedRoomAlias: String?
|
|
open var resolveRoomAliasRoomAliasReceivedRoomAlias: String? {
|
|
get { resolveRoomAliasRoomAliasReceivedRoomAliasLock.withLock { resolveRoomAliasRoomAliasUnderlyingReceivedRoomAlias } }
|
|
set { resolveRoomAliasRoomAliasReceivedRoomAliasLock.withLock { resolveRoomAliasRoomAliasUnderlyingReceivedRoomAlias = newValue } }
|
|
}
|
|
private let resolveRoomAliasRoomAliasReceivedInvocationsLock = NSLock()
|
|
private var resolveRoomAliasRoomAliasUnderlyingReceivedInvocations: [String] = []
|
|
open var resolveRoomAliasRoomAliasReceivedInvocations: [String] {
|
|
get { resolveRoomAliasRoomAliasReceivedInvocationsLock.withLock { resolveRoomAliasRoomAliasUnderlyingReceivedInvocations } }
|
|
set { resolveRoomAliasRoomAliasReceivedInvocationsLock.withLock { resolveRoomAliasRoomAliasUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let resolveRoomAliasRoomAliasReturnValueLock = NSLock()
|
|
open var resolveRoomAliasRoomAliasUnderlyingReturnValue: ResolvedRoomAlias?
|
|
open var resolveRoomAliasRoomAliasReturnValue: ResolvedRoomAlias? {
|
|
get { resolveRoomAliasRoomAliasReturnValueLock.withLock { resolveRoomAliasRoomAliasUnderlyingReturnValue } }
|
|
set { resolveRoomAliasRoomAliasReturnValueLock.withLock { resolveRoomAliasRoomAliasUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var resolveRoomAliasRoomAliasClosure: ((String) async throws -> ResolvedRoomAlias?)?
|
|
|
|
open override func resolveRoomAlias(roomAlias: String) async throws -> ResolvedRoomAlias? {
|
|
if let error = resolveRoomAliasRoomAliasThrowableError {
|
|
throw error
|
|
}
|
|
resolveRoomAliasRoomAliasCallsCountLock.withLock { resolveRoomAliasRoomAliasUnderlyingCallsCount += 1 }
|
|
resolveRoomAliasRoomAliasReceivedRoomAlias = roomAlias
|
|
resolveRoomAliasRoomAliasReceivedInvocationsLock.withLock { resolveRoomAliasRoomAliasUnderlyingReceivedInvocations.append(roomAlias) }
|
|
if let resolveRoomAliasRoomAliasClosure = resolveRoomAliasRoomAliasClosure {
|
|
return try await resolveRoomAliasRoomAliasClosure(roomAlias)
|
|
} else {
|
|
return resolveRoomAliasRoomAliasReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - restoreSession
|
|
|
|
open var restoreSessionSessionThrowableError: Error?
|
|
private let restoreSessionSessionCallsCountLock = NSLock()
|
|
private var restoreSessionSessionUnderlyingCallsCount = 0
|
|
open var restoreSessionSessionCallsCount: Int {
|
|
get { restoreSessionSessionCallsCountLock.withLock { restoreSessionSessionUnderlyingCallsCount } }
|
|
set { restoreSessionSessionCallsCountLock.withLock { restoreSessionSessionUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var restoreSessionSessionCalled: Bool {
|
|
return restoreSessionSessionCallsCount > 0
|
|
}
|
|
private let restoreSessionSessionReceivedSessionLock = NSLock()
|
|
private var restoreSessionSessionUnderlyingReceivedSession: Session?
|
|
open var restoreSessionSessionReceivedSession: Session? {
|
|
get { restoreSessionSessionReceivedSessionLock.withLock { restoreSessionSessionUnderlyingReceivedSession } }
|
|
set { restoreSessionSessionReceivedSessionLock.withLock { restoreSessionSessionUnderlyingReceivedSession = newValue } }
|
|
}
|
|
private let restoreSessionSessionReceivedInvocationsLock = NSLock()
|
|
private var restoreSessionSessionUnderlyingReceivedInvocations: [Session] = []
|
|
open var restoreSessionSessionReceivedInvocations: [Session] {
|
|
get { restoreSessionSessionReceivedInvocationsLock.withLock { restoreSessionSessionUnderlyingReceivedInvocations } }
|
|
set { restoreSessionSessionReceivedInvocationsLock.withLock { restoreSessionSessionUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var restoreSessionSessionClosure: ((Session) async throws -> Void)?
|
|
|
|
open override func restoreSession(session: Session) async throws {
|
|
if let error = restoreSessionSessionThrowableError {
|
|
throw error
|
|
}
|
|
restoreSessionSessionCallsCountLock.withLock { restoreSessionSessionUnderlyingCallsCount += 1 }
|
|
restoreSessionSessionReceivedSession = session
|
|
restoreSessionSessionReceivedInvocationsLock.withLock { restoreSessionSessionUnderlyingReceivedInvocations.append(session) }
|
|
try await restoreSessionSessionClosure?(session)
|
|
}
|
|
|
|
//MARK: - restoreSessionWith
|
|
|
|
open var restoreSessionWithSessionRoomLoadSettingsThrowableError: Error?
|
|
private let restoreSessionWithSessionRoomLoadSettingsCallsCountLock = NSLock()
|
|
private var restoreSessionWithSessionRoomLoadSettingsUnderlyingCallsCount = 0
|
|
open var restoreSessionWithSessionRoomLoadSettingsCallsCount: Int {
|
|
get { restoreSessionWithSessionRoomLoadSettingsCallsCountLock.withLock { restoreSessionWithSessionRoomLoadSettingsUnderlyingCallsCount } }
|
|
set { restoreSessionWithSessionRoomLoadSettingsCallsCountLock.withLock { restoreSessionWithSessionRoomLoadSettingsUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var restoreSessionWithSessionRoomLoadSettingsCalled: Bool {
|
|
return restoreSessionWithSessionRoomLoadSettingsCallsCount > 0
|
|
}
|
|
private let restoreSessionWithSessionRoomLoadSettingsReceivedArgumentsLock = NSLock()
|
|
private var restoreSessionWithSessionRoomLoadSettingsUnderlyingReceivedArguments: (session: Session, roomLoadSettings: RoomLoadSettings)?
|
|
open var restoreSessionWithSessionRoomLoadSettingsReceivedArguments: (session: Session, roomLoadSettings: RoomLoadSettings)? {
|
|
get { restoreSessionWithSessionRoomLoadSettingsReceivedArgumentsLock.withLock { restoreSessionWithSessionRoomLoadSettingsUnderlyingReceivedArguments } }
|
|
set { restoreSessionWithSessionRoomLoadSettingsReceivedArgumentsLock.withLock { restoreSessionWithSessionRoomLoadSettingsUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let restoreSessionWithSessionRoomLoadSettingsReceivedInvocationsLock = NSLock()
|
|
private var restoreSessionWithSessionRoomLoadSettingsUnderlyingReceivedInvocations: [(session: Session, roomLoadSettings: RoomLoadSettings)] = []
|
|
open var restoreSessionWithSessionRoomLoadSettingsReceivedInvocations: [(session: Session, roomLoadSettings: RoomLoadSettings)] {
|
|
get { restoreSessionWithSessionRoomLoadSettingsReceivedInvocationsLock.withLock { restoreSessionWithSessionRoomLoadSettingsUnderlyingReceivedInvocations } }
|
|
set { restoreSessionWithSessionRoomLoadSettingsReceivedInvocationsLock.withLock { restoreSessionWithSessionRoomLoadSettingsUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var restoreSessionWithSessionRoomLoadSettingsClosure: ((Session, RoomLoadSettings) async throws -> Void)?
|
|
|
|
open override func restoreSessionWith(session: Session, roomLoadSettings: RoomLoadSettings) async throws {
|
|
if let error = restoreSessionWithSessionRoomLoadSettingsThrowableError {
|
|
throw error
|
|
}
|
|
restoreSessionWithSessionRoomLoadSettingsCallsCountLock.withLock { restoreSessionWithSessionRoomLoadSettingsUnderlyingCallsCount += 1 }
|
|
restoreSessionWithSessionRoomLoadSettingsReceivedArguments = (session: session, roomLoadSettings: roomLoadSettings)
|
|
restoreSessionWithSessionRoomLoadSettingsReceivedInvocationsLock.withLock { restoreSessionWithSessionRoomLoadSettingsUnderlyingReceivedInvocations.append((session: session, roomLoadSettings: roomLoadSettings)) }
|
|
try await restoreSessionWithSessionRoomLoadSettingsClosure?(session, roomLoadSettings)
|
|
}
|
|
|
|
//MARK: - resume
|
|
|
|
open var resumeThrowableError: Error?
|
|
private let resumeCallsCountLock = NSLock()
|
|
private var resumeUnderlyingCallsCount = 0
|
|
open var resumeCallsCount: Int {
|
|
get { resumeCallsCountLock.withLock { resumeUnderlyingCallsCount } }
|
|
set { resumeCallsCountLock.withLock { resumeUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var resumeCalled: Bool {
|
|
return resumeCallsCount > 0
|
|
}
|
|
open var resumeClosure: (() async throws -> Void)?
|
|
|
|
open override func resume() async throws {
|
|
if let error = resumeThrowableError {
|
|
throw error
|
|
}
|
|
resumeCallsCountLock.withLock { resumeUnderlyingCallsCount += 1 }
|
|
try await resumeClosure?()
|
|
}
|
|
|
|
//MARK: - roomAliasExists
|
|
|
|
open var roomAliasExistsRoomAliasThrowableError: Error?
|
|
private let roomAliasExistsRoomAliasCallsCountLock = NSLock()
|
|
private var roomAliasExistsRoomAliasUnderlyingCallsCount = 0
|
|
open var roomAliasExistsRoomAliasCallsCount: Int {
|
|
get { roomAliasExistsRoomAliasCallsCountLock.withLock { roomAliasExistsRoomAliasUnderlyingCallsCount } }
|
|
set { roomAliasExistsRoomAliasCallsCountLock.withLock { roomAliasExistsRoomAliasUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var roomAliasExistsRoomAliasCalled: Bool {
|
|
return roomAliasExistsRoomAliasCallsCount > 0
|
|
}
|
|
private let roomAliasExistsRoomAliasReceivedRoomAliasLock = NSLock()
|
|
private var roomAliasExistsRoomAliasUnderlyingReceivedRoomAlias: String?
|
|
open var roomAliasExistsRoomAliasReceivedRoomAlias: String? {
|
|
get { roomAliasExistsRoomAliasReceivedRoomAliasLock.withLock { roomAliasExistsRoomAliasUnderlyingReceivedRoomAlias } }
|
|
set { roomAliasExistsRoomAliasReceivedRoomAliasLock.withLock { roomAliasExistsRoomAliasUnderlyingReceivedRoomAlias = newValue } }
|
|
}
|
|
private let roomAliasExistsRoomAliasReceivedInvocationsLock = NSLock()
|
|
private var roomAliasExistsRoomAliasUnderlyingReceivedInvocations: [String] = []
|
|
open var roomAliasExistsRoomAliasReceivedInvocations: [String] {
|
|
get { roomAliasExistsRoomAliasReceivedInvocationsLock.withLock { roomAliasExistsRoomAliasUnderlyingReceivedInvocations } }
|
|
set { roomAliasExistsRoomAliasReceivedInvocationsLock.withLock { roomAliasExistsRoomAliasUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let roomAliasExistsRoomAliasReturnValueLock = NSLock()
|
|
open var roomAliasExistsRoomAliasUnderlyingReturnValue: Bool!
|
|
open var roomAliasExistsRoomAliasReturnValue: Bool! {
|
|
get { roomAliasExistsRoomAliasReturnValueLock.withLock { roomAliasExistsRoomAliasUnderlyingReturnValue } }
|
|
set { roomAliasExistsRoomAliasReturnValueLock.withLock { roomAliasExistsRoomAliasUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var roomAliasExistsRoomAliasClosure: ((String) async throws -> Bool)?
|
|
|
|
open override func roomAliasExists(roomAlias: String) async throws -> Bool {
|
|
if let error = roomAliasExistsRoomAliasThrowableError {
|
|
throw error
|
|
}
|
|
roomAliasExistsRoomAliasCallsCountLock.withLock { roomAliasExistsRoomAliasUnderlyingCallsCount += 1 }
|
|
roomAliasExistsRoomAliasReceivedRoomAlias = roomAlias
|
|
roomAliasExistsRoomAliasReceivedInvocationsLock.withLock { roomAliasExistsRoomAliasUnderlyingReceivedInvocations.append(roomAlias) }
|
|
if let roomAliasExistsRoomAliasClosure = roomAliasExistsRoomAliasClosure {
|
|
return try await roomAliasExistsRoomAliasClosure(roomAlias)
|
|
} else {
|
|
return roomAliasExistsRoomAliasReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - roomDirectorySearch
|
|
|
|
private let roomDirectorySearchCallsCountLock = NSLock()
|
|
private var roomDirectorySearchUnderlyingCallsCount = 0
|
|
open var roomDirectorySearchCallsCount: Int {
|
|
get { roomDirectorySearchCallsCountLock.withLock { roomDirectorySearchUnderlyingCallsCount } }
|
|
set { roomDirectorySearchCallsCountLock.withLock { roomDirectorySearchUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var roomDirectorySearchCalled: Bool {
|
|
return roomDirectorySearchCallsCount > 0
|
|
}
|
|
|
|
private let roomDirectorySearchReturnValueLock = NSLock()
|
|
open var roomDirectorySearchUnderlyingReturnValue: RoomDirectorySearch!
|
|
open var roomDirectorySearchReturnValue: RoomDirectorySearch! {
|
|
get { roomDirectorySearchReturnValueLock.withLock { roomDirectorySearchUnderlyingReturnValue } }
|
|
set { roomDirectorySearchReturnValueLock.withLock { roomDirectorySearchUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var roomDirectorySearchClosure: (() -> RoomDirectorySearch)?
|
|
|
|
open override func roomDirectorySearch() -> RoomDirectorySearch {
|
|
roomDirectorySearchCallsCountLock.withLock { roomDirectorySearchUnderlyingCallsCount += 1 }
|
|
if let roomDirectorySearchClosure = roomDirectorySearchClosure {
|
|
return roomDirectorySearchClosure()
|
|
} else {
|
|
return roomDirectorySearchReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - rooms
|
|
|
|
private let roomsCallsCountLock = NSLock()
|
|
private var roomsUnderlyingCallsCount = 0
|
|
open var roomsCallsCount: Int {
|
|
get { roomsCallsCountLock.withLock { roomsUnderlyingCallsCount } }
|
|
set { roomsCallsCountLock.withLock { roomsUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var roomsCalled: Bool {
|
|
return roomsCallsCount > 0
|
|
}
|
|
|
|
private let roomsReturnValueLock = NSLock()
|
|
open var roomsUnderlyingReturnValue: [Room]!
|
|
open var roomsReturnValue: [Room]! {
|
|
get { roomsReturnValueLock.withLock { roomsUnderlyingReturnValue } }
|
|
set { roomsReturnValueLock.withLock { roomsUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var roomsClosure: (() -> [Room])?
|
|
|
|
open override func rooms() -> [Room] {
|
|
roomsCallsCountLock.withLock { roomsUnderlyingCallsCount += 1 }
|
|
if let roomsClosure = roomsClosure {
|
|
return roomsClosure()
|
|
} else {
|
|
return roomsReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - searchUsers
|
|
|
|
open var searchUsersSearchTermLimitThrowableError: Error?
|
|
private let searchUsersSearchTermLimitCallsCountLock = NSLock()
|
|
private var searchUsersSearchTermLimitUnderlyingCallsCount = 0
|
|
open var searchUsersSearchTermLimitCallsCount: Int {
|
|
get { searchUsersSearchTermLimitCallsCountLock.withLock { searchUsersSearchTermLimitUnderlyingCallsCount } }
|
|
set { searchUsersSearchTermLimitCallsCountLock.withLock { searchUsersSearchTermLimitUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var searchUsersSearchTermLimitCalled: Bool {
|
|
return searchUsersSearchTermLimitCallsCount > 0
|
|
}
|
|
private let searchUsersSearchTermLimitReceivedArgumentsLock = NSLock()
|
|
private var searchUsersSearchTermLimitUnderlyingReceivedArguments: (searchTerm: String, limit: UInt64)?
|
|
open var searchUsersSearchTermLimitReceivedArguments: (searchTerm: String, limit: UInt64)? {
|
|
get { searchUsersSearchTermLimitReceivedArgumentsLock.withLock { searchUsersSearchTermLimitUnderlyingReceivedArguments } }
|
|
set { searchUsersSearchTermLimitReceivedArgumentsLock.withLock { searchUsersSearchTermLimitUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let searchUsersSearchTermLimitReceivedInvocationsLock = NSLock()
|
|
private var searchUsersSearchTermLimitUnderlyingReceivedInvocations: [(searchTerm: String, limit: UInt64)] = []
|
|
open var searchUsersSearchTermLimitReceivedInvocations: [(searchTerm: String, limit: UInt64)] {
|
|
get { searchUsersSearchTermLimitReceivedInvocationsLock.withLock { searchUsersSearchTermLimitUnderlyingReceivedInvocations } }
|
|
set { searchUsersSearchTermLimitReceivedInvocationsLock.withLock { searchUsersSearchTermLimitUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let searchUsersSearchTermLimitReturnValueLock = NSLock()
|
|
open var searchUsersSearchTermLimitUnderlyingReturnValue: SearchUsersResults!
|
|
open var searchUsersSearchTermLimitReturnValue: SearchUsersResults! {
|
|
get { searchUsersSearchTermLimitReturnValueLock.withLock { searchUsersSearchTermLimitUnderlyingReturnValue } }
|
|
set { searchUsersSearchTermLimitReturnValueLock.withLock { searchUsersSearchTermLimitUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var searchUsersSearchTermLimitClosure: ((String, UInt64) async throws -> SearchUsersResults)?
|
|
|
|
open override func searchUsers(searchTerm: String, limit: UInt64) async throws -> SearchUsersResults {
|
|
if let error = searchUsersSearchTermLimitThrowableError {
|
|
throw error
|
|
}
|
|
searchUsersSearchTermLimitCallsCountLock.withLock { searchUsersSearchTermLimitUnderlyingCallsCount += 1 }
|
|
searchUsersSearchTermLimitReceivedArguments = (searchTerm: searchTerm, limit: limit)
|
|
searchUsersSearchTermLimitReceivedInvocationsLock.withLock { searchUsersSearchTermLimitUnderlyingReceivedInvocations.append((searchTerm: searchTerm, limit: limit)) }
|
|
if let searchUsersSearchTermLimitClosure = searchUsersSearchTermLimitClosure {
|
|
return try await searchUsersSearchTermLimitClosure(searchTerm, limit)
|
|
} else {
|
|
return searchUsersSearchTermLimitReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - server
|
|
|
|
private let serverCallsCountLock = NSLock()
|
|
private var serverUnderlyingCallsCount = 0
|
|
open var serverCallsCount: Int {
|
|
get { serverCallsCountLock.withLock { serverUnderlyingCallsCount } }
|
|
set { serverCallsCountLock.withLock { serverUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var serverCalled: Bool {
|
|
return serverCallsCount > 0
|
|
}
|
|
|
|
private let serverReturnValueLock = NSLock()
|
|
open var serverUnderlyingReturnValue: String?
|
|
open var serverReturnValue: String? {
|
|
get { serverReturnValueLock.withLock { serverUnderlyingReturnValue } }
|
|
set { serverReturnValueLock.withLock { serverUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var serverClosure: (() -> String?)?
|
|
|
|
open override func server() -> String? {
|
|
serverCallsCountLock.withLock { serverUnderlyingCallsCount += 1 }
|
|
if let serverClosure = serverClosure {
|
|
return serverClosure()
|
|
} else {
|
|
return serverReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - serverVendorInfo
|
|
|
|
open var serverVendorInfoThrowableError: Error?
|
|
private let serverVendorInfoCallsCountLock = NSLock()
|
|
private var serverVendorInfoUnderlyingCallsCount = 0
|
|
open var serverVendorInfoCallsCount: Int {
|
|
get { serverVendorInfoCallsCountLock.withLock { serverVendorInfoUnderlyingCallsCount } }
|
|
set { serverVendorInfoCallsCountLock.withLock { serverVendorInfoUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var serverVendorInfoCalled: Bool {
|
|
return serverVendorInfoCallsCount > 0
|
|
}
|
|
|
|
private let serverVendorInfoReturnValueLock = NSLock()
|
|
open var serverVendorInfoUnderlyingReturnValue: ServerVendorInfo!
|
|
open var serverVendorInfoReturnValue: ServerVendorInfo! {
|
|
get { serverVendorInfoReturnValueLock.withLock { serverVendorInfoUnderlyingReturnValue } }
|
|
set { serverVendorInfoReturnValueLock.withLock { serverVendorInfoUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var serverVendorInfoClosure: (() async throws -> ServerVendorInfo)?
|
|
|
|
open override func serverVendorInfo() async throws -> ServerVendorInfo {
|
|
if let error = serverVendorInfoThrowableError {
|
|
throw error
|
|
}
|
|
serverVendorInfoCallsCountLock.withLock { serverVendorInfoUnderlyingCallsCount += 1 }
|
|
if let serverVendorInfoClosure = serverVendorInfoClosure {
|
|
return try await serverVendorInfoClosure()
|
|
} else {
|
|
return serverVendorInfoReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - session
|
|
|
|
open var sessionThrowableError: Error?
|
|
private let sessionCallsCountLock = NSLock()
|
|
private var sessionUnderlyingCallsCount = 0
|
|
open var sessionCallsCount: Int {
|
|
get { sessionCallsCountLock.withLock { sessionUnderlyingCallsCount } }
|
|
set { sessionCallsCountLock.withLock { sessionUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var sessionCalled: Bool {
|
|
return sessionCallsCount > 0
|
|
}
|
|
|
|
private let sessionReturnValueLock = NSLock()
|
|
open var sessionUnderlyingReturnValue: Session!
|
|
open var sessionReturnValue: Session! {
|
|
get { sessionReturnValueLock.withLock { sessionUnderlyingReturnValue } }
|
|
set { sessionReturnValueLock.withLock { sessionUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var sessionClosure: (() throws -> Session)?
|
|
|
|
open override func session() throws -> Session {
|
|
if let error = sessionThrowableError {
|
|
throw error
|
|
}
|
|
sessionCallsCountLock.withLock { sessionUnderlyingCallsCount += 1 }
|
|
if let sessionClosure = sessionClosure {
|
|
return try sessionClosure()
|
|
} else {
|
|
return sessionReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - setAccountData
|
|
|
|
open var setAccountDataEventTypeContentThrowableError: Error?
|
|
private let setAccountDataEventTypeContentCallsCountLock = NSLock()
|
|
private var setAccountDataEventTypeContentUnderlyingCallsCount = 0
|
|
open var setAccountDataEventTypeContentCallsCount: Int {
|
|
get { setAccountDataEventTypeContentCallsCountLock.withLock { setAccountDataEventTypeContentUnderlyingCallsCount } }
|
|
set { setAccountDataEventTypeContentCallsCountLock.withLock { setAccountDataEventTypeContentUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var setAccountDataEventTypeContentCalled: Bool {
|
|
return setAccountDataEventTypeContentCallsCount > 0
|
|
}
|
|
private let setAccountDataEventTypeContentReceivedArgumentsLock = NSLock()
|
|
private var setAccountDataEventTypeContentUnderlyingReceivedArguments: (eventType: String, content: String)?
|
|
open var setAccountDataEventTypeContentReceivedArguments: (eventType: String, content: String)? {
|
|
get { setAccountDataEventTypeContentReceivedArgumentsLock.withLock { setAccountDataEventTypeContentUnderlyingReceivedArguments } }
|
|
set { setAccountDataEventTypeContentReceivedArgumentsLock.withLock { setAccountDataEventTypeContentUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let setAccountDataEventTypeContentReceivedInvocationsLock = NSLock()
|
|
private var setAccountDataEventTypeContentUnderlyingReceivedInvocations: [(eventType: String, content: String)] = []
|
|
open var setAccountDataEventTypeContentReceivedInvocations: [(eventType: String, content: String)] {
|
|
get { setAccountDataEventTypeContentReceivedInvocationsLock.withLock { setAccountDataEventTypeContentUnderlyingReceivedInvocations } }
|
|
set { setAccountDataEventTypeContentReceivedInvocationsLock.withLock { setAccountDataEventTypeContentUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var setAccountDataEventTypeContentClosure: ((String, String) async throws -> Void)?
|
|
|
|
open override func setAccountData(eventType: String, content: String) async throws {
|
|
if let error = setAccountDataEventTypeContentThrowableError {
|
|
throw error
|
|
}
|
|
setAccountDataEventTypeContentCallsCountLock.withLock { setAccountDataEventTypeContentUnderlyingCallsCount += 1 }
|
|
setAccountDataEventTypeContentReceivedArguments = (eventType: eventType, content: content)
|
|
setAccountDataEventTypeContentReceivedInvocationsLock.withLock { setAccountDataEventTypeContentUnderlyingReceivedInvocations.append((eventType: eventType, content: content)) }
|
|
try await setAccountDataEventTypeContentClosure?(eventType, content)
|
|
}
|
|
|
|
//MARK: - setAvatarUrl
|
|
|
|
open var setAvatarUrlUrlThrowableError: Error?
|
|
private let setAvatarUrlUrlCallsCountLock = NSLock()
|
|
private var setAvatarUrlUrlUnderlyingCallsCount = 0
|
|
open var setAvatarUrlUrlCallsCount: Int {
|
|
get { setAvatarUrlUrlCallsCountLock.withLock { setAvatarUrlUrlUnderlyingCallsCount } }
|
|
set { setAvatarUrlUrlCallsCountLock.withLock { setAvatarUrlUrlUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var setAvatarUrlUrlCalled: Bool {
|
|
return setAvatarUrlUrlCallsCount > 0
|
|
}
|
|
private let setAvatarUrlUrlReceivedUrlLock = NSLock()
|
|
private var setAvatarUrlUrlUnderlyingReceivedUrl: String?
|
|
open var setAvatarUrlUrlReceivedUrl: String? {
|
|
get { setAvatarUrlUrlReceivedUrlLock.withLock { setAvatarUrlUrlUnderlyingReceivedUrl } }
|
|
set { setAvatarUrlUrlReceivedUrlLock.withLock { setAvatarUrlUrlUnderlyingReceivedUrl = newValue } }
|
|
}
|
|
private let setAvatarUrlUrlReceivedInvocationsLock = NSLock()
|
|
private var setAvatarUrlUrlUnderlyingReceivedInvocations: [String] = []
|
|
open var setAvatarUrlUrlReceivedInvocations: [String] {
|
|
get { setAvatarUrlUrlReceivedInvocationsLock.withLock { setAvatarUrlUrlUnderlyingReceivedInvocations } }
|
|
set { setAvatarUrlUrlReceivedInvocationsLock.withLock { setAvatarUrlUrlUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var setAvatarUrlUrlClosure: ((String) async throws -> Void)?
|
|
|
|
open override func setAvatarUrl(url: String) async throws {
|
|
if let error = setAvatarUrlUrlThrowableError {
|
|
throw error
|
|
}
|
|
setAvatarUrlUrlCallsCountLock.withLock { setAvatarUrlUrlUnderlyingCallsCount += 1 }
|
|
setAvatarUrlUrlReceivedUrl = url
|
|
setAvatarUrlUrlReceivedInvocationsLock.withLock { setAvatarUrlUrlUnderlyingReceivedInvocations.append(url) }
|
|
try await setAvatarUrlUrlClosure?(url)
|
|
}
|
|
|
|
//MARK: - setContentScanner
|
|
|
|
private let setContentScannerContentScannerCallsCountLock = NSLock()
|
|
private var setContentScannerContentScannerUnderlyingCallsCount = 0
|
|
open var setContentScannerContentScannerCallsCount: Int {
|
|
get { setContentScannerContentScannerCallsCountLock.withLock { setContentScannerContentScannerUnderlyingCallsCount } }
|
|
set { setContentScannerContentScannerCallsCountLock.withLock { setContentScannerContentScannerUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var setContentScannerContentScannerCalled: Bool {
|
|
return setContentScannerContentScannerCallsCount > 0
|
|
}
|
|
private let setContentScannerContentScannerReceivedContentScannerLock = NSLock()
|
|
private var setContentScannerContentScannerUnderlyingReceivedContentScanner: ContentScanner?
|
|
open var setContentScannerContentScannerReceivedContentScanner: ContentScanner? {
|
|
get { setContentScannerContentScannerReceivedContentScannerLock.withLock { setContentScannerContentScannerUnderlyingReceivedContentScanner } }
|
|
set { setContentScannerContentScannerReceivedContentScannerLock.withLock { setContentScannerContentScannerUnderlyingReceivedContentScanner = newValue } }
|
|
}
|
|
private let setContentScannerContentScannerReceivedInvocationsLock = NSLock()
|
|
private var setContentScannerContentScannerUnderlyingReceivedInvocations: [ContentScanner?] = []
|
|
open var setContentScannerContentScannerReceivedInvocations: [ContentScanner?] {
|
|
get { setContentScannerContentScannerReceivedInvocationsLock.withLock { setContentScannerContentScannerUnderlyingReceivedInvocations } }
|
|
set { setContentScannerContentScannerReceivedInvocationsLock.withLock { setContentScannerContentScannerUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var setContentScannerContentScannerClosure: ((ContentScanner?) async -> Void)?
|
|
|
|
open override func setContentScanner(contentScanner: ContentScanner?) async {
|
|
setContentScannerContentScannerCallsCountLock.withLock { setContentScannerContentScannerUnderlyingCallsCount += 1 }
|
|
setContentScannerContentScannerReceivedContentScanner = contentScanner
|
|
setContentScannerContentScannerReceivedInvocationsLock.withLock { setContentScannerContentScannerUnderlyingReceivedInvocations.append(contentScanner) }
|
|
await setContentScannerContentScannerClosure?(contentScanner)
|
|
}
|
|
|
|
//MARK: - setDelegate
|
|
|
|
open var setDelegateDelegateThrowableError: Error?
|
|
private let setDelegateDelegateCallsCountLock = NSLock()
|
|
private var setDelegateDelegateUnderlyingCallsCount = 0
|
|
open var setDelegateDelegateCallsCount: Int {
|
|
get { setDelegateDelegateCallsCountLock.withLock { setDelegateDelegateUnderlyingCallsCount } }
|
|
set { setDelegateDelegateCallsCountLock.withLock { setDelegateDelegateUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var setDelegateDelegateCalled: Bool {
|
|
return setDelegateDelegateCallsCount > 0
|
|
}
|
|
private let setDelegateDelegateReceivedDelegateLock = NSLock()
|
|
private var setDelegateDelegateUnderlyingReceivedDelegate: ClientDelegate?
|
|
open var setDelegateDelegateReceivedDelegate: ClientDelegate? {
|
|
get { setDelegateDelegateReceivedDelegateLock.withLock { setDelegateDelegateUnderlyingReceivedDelegate } }
|
|
set { setDelegateDelegateReceivedDelegateLock.withLock { setDelegateDelegateUnderlyingReceivedDelegate = newValue } }
|
|
}
|
|
private let setDelegateDelegateReceivedInvocationsLock = NSLock()
|
|
private var setDelegateDelegateUnderlyingReceivedInvocations: [ClientDelegate?] = []
|
|
open var setDelegateDelegateReceivedInvocations: [ClientDelegate?] {
|
|
get { setDelegateDelegateReceivedInvocationsLock.withLock { setDelegateDelegateUnderlyingReceivedInvocations } }
|
|
set { setDelegateDelegateReceivedInvocationsLock.withLock { setDelegateDelegateUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let setDelegateDelegateReturnValueLock = NSLock()
|
|
open var setDelegateDelegateUnderlyingReturnValue: TaskHandle?
|
|
open var setDelegateDelegateReturnValue: TaskHandle? {
|
|
get { setDelegateDelegateReturnValueLock.withLock { setDelegateDelegateUnderlyingReturnValue } }
|
|
set { setDelegateDelegateReturnValueLock.withLock { setDelegateDelegateUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var setDelegateDelegateClosure: ((ClientDelegate?) throws -> TaskHandle?)?
|
|
|
|
open override func setDelegate(delegate: ClientDelegate?) throws -> TaskHandle? {
|
|
if let error = setDelegateDelegateThrowableError {
|
|
throw error
|
|
}
|
|
setDelegateDelegateCallsCountLock.withLock { setDelegateDelegateUnderlyingCallsCount += 1 }
|
|
setDelegateDelegateReceivedDelegate = delegate
|
|
setDelegateDelegateReceivedInvocationsLock.withLock { setDelegateDelegateUnderlyingReceivedInvocations.append(delegate) }
|
|
if let setDelegateDelegateClosure = setDelegateDelegateClosure {
|
|
return try setDelegateDelegateClosure(delegate)
|
|
} else {
|
|
return setDelegateDelegateReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - setDisplayName
|
|
|
|
open var setDisplayNameNameThrowableError: Error?
|
|
private let setDisplayNameNameCallsCountLock = NSLock()
|
|
private var setDisplayNameNameUnderlyingCallsCount = 0
|
|
open var setDisplayNameNameCallsCount: Int {
|
|
get { setDisplayNameNameCallsCountLock.withLock { setDisplayNameNameUnderlyingCallsCount } }
|
|
set { setDisplayNameNameCallsCountLock.withLock { setDisplayNameNameUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var setDisplayNameNameCalled: Bool {
|
|
return setDisplayNameNameCallsCount > 0
|
|
}
|
|
private let setDisplayNameNameReceivedNameLock = NSLock()
|
|
private var setDisplayNameNameUnderlyingReceivedName: String?
|
|
open var setDisplayNameNameReceivedName: String? {
|
|
get { setDisplayNameNameReceivedNameLock.withLock { setDisplayNameNameUnderlyingReceivedName } }
|
|
set { setDisplayNameNameReceivedNameLock.withLock { setDisplayNameNameUnderlyingReceivedName = newValue } }
|
|
}
|
|
private let setDisplayNameNameReceivedInvocationsLock = NSLock()
|
|
private var setDisplayNameNameUnderlyingReceivedInvocations: [String] = []
|
|
open var setDisplayNameNameReceivedInvocations: [String] {
|
|
get { setDisplayNameNameReceivedInvocationsLock.withLock { setDisplayNameNameUnderlyingReceivedInvocations } }
|
|
set { setDisplayNameNameReceivedInvocationsLock.withLock { setDisplayNameNameUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var setDisplayNameNameClosure: ((String) async throws -> Void)?
|
|
|
|
open override func setDisplayName(name: String) async throws {
|
|
if let error = setDisplayNameNameThrowableError {
|
|
throw error
|
|
}
|
|
setDisplayNameNameCallsCountLock.withLock { setDisplayNameNameUnderlyingCallsCount += 1 }
|
|
setDisplayNameNameReceivedName = name
|
|
setDisplayNameNameReceivedInvocationsLock.withLock { setDisplayNameNameUnderlyingReceivedInvocations.append(name) }
|
|
try await setDisplayNameNameClosure?(name)
|
|
}
|
|
|
|
//MARK: - setInviteAvatarsDisplayPolicy
|
|
|
|
open var setInviteAvatarsDisplayPolicyPolicyThrowableError: Error?
|
|
private let setInviteAvatarsDisplayPolicyPolicyCallsCountLock = NSLock()
|
|
private var setInviteAvatarsDisplayPolicyPolicyUnderlyingCallsCount = 0
|
|
open var setInviteAvatarsDisplayPolicyPolicyCallsCount: Int {
|
|
get { setInviteAvatarsDisplayPolicyPolicyCallsCountLock.withLock { setInviteAvatarsDisplayPolicyPolicyUnderlyingCallsCount } }
|
|
set { setInviteAvatarsDisplayPolicyPolicyCallsCountLock.withLock { setInviteAvatarsDisplayPolicyPolicyUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var setInviteAvatarsDisplayPolicyPolicyCalled: Bool {
|
|
return setInviteAvatarsDisplayPolicyPolicyCallsCount > 0
|
|
}
|
|
private let setInviteAvatarsDisplayPolicyPolicyReceivedPolicyLock = NSLock()
|
|
private var setInviteAvatarsDisplayPolicyPolicyUnderlyingReceivedPolicy: InviteAvatars?
|
|
open var setInviteAvatarsDisplayPolicyPolicyReceivedPolicy: InviteAvatars? {
|
|
get { setInviteAvatarsDisplayPolicyPolicyReceivedPolicyLock.withLock { setInviteAvatarsDisplayPolicyPolicyUnderlyingReceivedPolicy } }
|
|
set { setInviteAvatarsDisplayPolicyPolicyReceivedPolicyLock.withLock { setInviteAvatarsDisplayPolicyPolicyUnderlyingReceivedPolicy = newValue } }
|
|
}
|
|
private let setInviteAvatarsDisplayPolicyPolicyReceivedInvocationsLock = NSLock()
|
|
private var setInviteAvatarsDisplayPolicyPolicyUnderlyingReceivedInvocations: [InviteAvatars] = []
|
|
open var setInviteAvatarsDisplayPolicyPolicyReceivedInvocations: [InviteAvatars] {
|
|
get { setInviteAvatarsDisplayPolicyPolicyReceivedInvocationsLock.withLock { setInviteAvatarsDisplayPolicyPolicyUnderlyingReceivedInvocations } }
|
|
set { setInviteAvatarsDisplayPolicyPolicyReceivedInvocationsLock.withLock { setInviteAvatarsDisplayPolicyPolicyUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var setInviteAvatarsDisplayPolicyPolicyClosure: ((InviteAvatars) async throws -> Void)?
|
|
|
|
open override func setInviteAvatarsDisplayPolicy(policy: InviteAvatars) async throws {
|
|
if let error = setInviteAvatarsDisplayPolicyPolicyThrowableError {
|
|
throw error
|
|
}
|
|
setInviteAvatarsDisplayPolicyPolicyCallsCountLock.withLock { setInviteAvatarsDisplayPolicyPolicyUnderlyingCallsCount += 1 }
|
|
setInviteAvatarsDisplayPolicyPolicyReceivedPolicy = policy
|
|
setInviteAvatarsDisplayPolicyPolicyReceivedInvocationsLock.withLock { setInviteAvatarsDisplayPolicyPolicyUnderlyingReceivedInvocations.append(policy) }
|
|
try await setInviteAvatarsDisplayPolicyPolicyClosure?(policy)
|
|
}
|
|
|
|
//MARK: - setMediaPreviewDisplayPolicy
|
|
|
|
open var setMediaPreviewDisplayPolicyPolicyThrowableError: Error?
|
|
private let setMediaPreviewDisplayPolicyPolicyCallsCountLock = NSLock()
|
|
private var setMediaPreviewDisplayPolicyPolicyUnderlyingCallsCount = 0
|
|
open var setMediaPreviewDisplayPolicyPolicyCallsCount: Int {
|
|
get { setMediaPreviewDisplayPolicyPolicyCallsCountLock.withLock { setMediaPreviewDisplayPolicyPolicyUnderlyingCallsCount } }
|
|
set { setMediaPreviewDisplayPolicyPolicyCallsCountLock.withLock { setMediaPreviewDisplayPolicyPolicyUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var setMediaPreviewDisplayPolicyPolicyCalled: Bool {
|
|
return setMediaPreviewDisplayPolicyPolicyCallsCount > 0
|
|
}
|
|
private let setMediaPreviewDisplayPolicyPolicyReceivedPolicyLock = NSLock()
|
|
private var setMediaPreviewDisplayPolicyPolicyUnderlyingReceivedPolicy: MediaPreviews?
|
|
open var setMediaPreviewDisplayPolicyPolicyReceivedPolicy: MediaPreviews? {
|
|
get { setMediaPreviewDisplayPolicyPolicyReceivedPolicyLock.withLock { setMediaPreviewDisplayPolicyPolicyUnderlyingReceivedPolicy } }
|
|
set { setMediaPreviewDisplayPolicyPolicyReceivedPolicyLock.withLock { setMediaPreviewDisplayPolicyPolicyUnderlyingReceivedPolicy = newValue } }
|
|
}
|
|
private let setMediaPreviewDisplayPolicyPolicyReceivedInvocationsLock = NSLock()
|
|
private var setMediaPreviewDisplayPolicyPolicyUnderlyingReceivedInvocations: [MediaPreviews] = []
|
|
open var setMediaPreviewDisplayPolicyPolicyReceivedInvocations: [MediaPreviews] {
|
|
get { setMediaPreviewDisplayPolicyPolicyReceivedInvocationsLock.withLock { setMediaPreviewDisplayPolicyPolicyUnderlyingReceivedInvocations } }
|
|
set { setMediaPreviewDisplayPolicyPolicyReceivedInvocationsLock.withLock { setMediaPreviewDisplayPolicyPolicyUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var setMediaPreviewDisplayPolicyPolicyClosure: ((MediaPreviews) async throws -> Void)?
|
|
|
|
open override func setMediaPreviewDisplayPolicy(policy: MediaPreviews) async throws {
|
|
if let error = setMediaPreviewDisplayPolicyPolicyThrowableError {
|
|
throw error
|
|
}
|
|
setMediaPreviewDisplayPolicyPolicyCallsCountLock.withLock { setMediaPreviewDisplayPolicyPolicyUnderlyingCallsCount += 1 }
|
|
setMediaPreviewDisplayPolicyPolicyReceivedPolicy = policy
|
|
setMediaPreviewDisplayPolicyPolicyReceivedInvocationsLock.withLock { setMediaPreviewDisplayPolicyPolicyUnderlyingReceivedInvocations.append(policy) }
|
|
try await setMediaPreviewDisplayPolicyPolicyClosure?(policy)
|
|
}
|
|
|
|
//MARK: - setMediaRetentionPolicy
|
|
|
|
open var setMediaRetentionPolicyPolicyThrowableError: Error?
|
|
private let setMediaRetentionPolicyPolicyCallsCountLock = NSLock()
|
|
private var setMediaRetentionPolicyPolicyUnderlyingCallsCount = 0
|
|
open var setMediaRetentionPolicyPolicyCallsCount: Int {
|
|
get { setMediaRetentionPolicyPolicyCallsCountLock.withLock { setMediaRetentionPolicyPolicyUnderlyingCallsCount } }
|
|
set { setMediaRetentionPolicyPolicyCallsCountLock.withLock { setMediaRetentionPolicyPolicyUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var setMediaRetentionPolicyPolicyCalled: Bool {
|
|
return setMediaRetentionPolicyPolicyCallsCount > 0
|
|
}
|
|
private let setMediaRetentionPolicyPolicyReceivedPolicyLock = NSLock()
|
|
private var setMediaRetentionPolicyPolicyUnderlyingReceivedPolicy: MediaRetentionPolicy?
|
|
open var setMediaRetentionPolicyPolicyReceivedPolicy: MediaRetentionPolicy? {
|
|
get { setMediaRetentionPolicyPolicyReceivedPolicyLock.withLock { setMediaRetentionPolicyPolicyUnderlyingReceivedPolicy } }
|
|
set { setMediaRetentionPolicyPolicyReceivedPolicyLock.withLock { setMediaRetentionPolicyPolicyUnderlyingReceivedPolicy = newValue } }
|
|
}
|
|
private let setMediaRetentionPolicyPolicyReceivedInvocationsLock = NSLock()
|
|
private var setMediaRetentionPolicyPolicyUnderlyingReceivedInvocations: [MediaRetentionPolicy] = []
|
|
open var setMediaRetentionPolicyPolicyReceivedInvocations: [MediaRetentionPolicy] {
|
|
get { setMediaRetentionPolicyPolicyReceivedInvocationsLock.withLock { setMediaRetentionPolicyPolicyUnderlyingReceivedInvocations } }
|
|
set { setMediaRetentionPolicyPolicyReceivedInvocationsLock.withLock { setMediaRetentionPolicyPolicyUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var setMediaRetentionPolicyPolicyClosure: ((MediaRetentionPolicy) async throws -> Void)?
|
|
|
|
open override func setMediaRetentionPolicy(policy: MediaRetentionPolicy) async throws {
|
|
if let error = setMediaRetentionPolicyPolicyThrowableError {
|
|
throw error
|
|
}
|
|
setMediaRetentionPolicyPolicyCallsCountLock.withLock { setMediaRetentionPolicyPolicyUnderlyingCallsCount += 1 }
|
|
setMediaRetentionPolicyPolicyReceivedPolicy = policy
|
|
setMediaRetentionPolicyPolicyReceivedInvocationsLock.withLock { setMediaRetentionPolicyPolicyUnderlyingReceivedInvocations.append(policy) }
|
|
try await setMediaRetentionPolicyPolicyClosure?(policy)
|
|
}
|
|
|
|
//MARK: - setPresence
|
|
|
|
open var setPresencePresenceImmediateThrowableError: Error?
|
|
private let setPresencePresenceImmediateCallsCountLock = NSLock()
|
|
private var setPresencePresenceImmediateUnderlyingCallsCount = 0
|
|
open var setPresencePresenceImmediateCallsCount: Int {
|
|
get { setPresencePresenceImmediateCallsCountLock.withLock { setPresencePresenceImmediateUnderlyingCallsCount } }
|
|
set { setPresencePresenceImmediateCallsCountLock.withLock { setPresencePresenceImmediateUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var setPresencePresenceImmediateCalled: Bool {
|
|
return setPresencePresenceImmediateCallsCount > 0
|
|
}
|
|
private let setPresencePresenceImmediateReceivedArgumentsLock = NSLock()
|
|
private var setPresencePresenceImmediateUnderlyingReceivedArguments: (presence: PresenceState, immediate: Bool)?
|
|
open var setPresencePresenceImmediateReceivedArguments: (presence: PresenceState, immediate: Bool)? {
|
|
get { setPresencePresenceImmediateReceivedArgumentsLock.withLock { setPresencePresenceImmediateUnderlyingReceivedArguments } }
|
|
set { setPresencePresenceImmediateReceivedArgumentsLock.withLock { setPresencePresenceImmediateUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let setPresencePresenceImmediateReceivedInvocationsLock = NSLock()
|
|
private var setPresencePresenceImmediateUnderlyingReceivedInvocations: [(presence: PresenceState, immediate: Bool)] = []
|
|
open var setPresencePresenceImmediateReceivedInvocations: [(presence: PresenceState, immediate: Bool)] {
|
|
get { setPresencePresenceImmediateReceivedInvocationsLock.withLock { setPresencePresenceImmediateUnderlyingReceivedInvocations } }
|
|
set { setPresencePresenceImmediateReceivedInvocationsLock.withLock { setPresencePresenceImmediateUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var setPresencePresenceImmediateClosure: ((PresenceState, Bool) async throws -> Void)?
|
|
|
|
open override func setPresence(presence: PresenceState, immediate: Bool) async throws {
|
|
if let error = setPresencePresenceImmediateThrowableError {
|
|
throw error
|
|
}
|
|
setPresencePresenceImmediateCallsCountLock.withLock { setPresencePresenceImmediateUnderlyingCallsCount += 1 }
|
|
setPresencePresenceImmediateReceivedArguments = (presence: presence, immediate: immediate)
|
|
setPresencePresenceImmediateReceivedInvocationsLock.withLock { setPresencePresenceImmediateUnderlyingReceivedInvocations.append((presence: presence, immediate: immediate)) }
|
|
try await setPresencePresenceImmediateClosure?(presence, immediate)
|
|
}
|
|
|
|
//MARK: - setPusher
|
|
|
|
open var setPusherIdentifiersKindAppDisplayNameDeviceDisplayNameProfileTagLangAppendThrowableError: Error?
|
|
private let setPusherIdentifiersKindAppDisplayNameDeviceDisplayNameProfileTagLangAppendCallsCountLock = NSLock()
|
|
private var setPusherIdentifiersKindAppDisplayNameDeviceDisplayNameProfileTagLangAppendUnderlyingCallsCount = 0
|
|
open var setPusherIdentifiersKindAppDisplayNameDeviceDisplayNameProfileTagLangAppendCallsCount: Int {
|
|
get { setPusherIdentifiersKindAppDisplayNameDeviceDisplayNameProfileTagLangAppendCallsCountLock.withLock { setPusherIdentifiersKindAppDisplayNameDeviceDisplayNameProfileTagLangAppendUnderlyingCallsCount } }
|
|
set { setPusherIdentifiersKindAppDisplayNameDeviceDisplayNameProfileTagLangAppendCallsCountLock.withLock { setPusherIdentifiersKindAppDisplayNameDeviceDisplayNameProfileTagLangAppendUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var setPusherIdentifiersKindAppDisplayNameDeviceDisplayNameProfileTagLangAppendCalled: Bool {
|
|
return setPusherIdentifiersKindAppDisplayNameDeviceDisplayNameProfileTagLangAppendCallsCount > 0
|
|
}
|
|
private let setPusherIdentifiersKindAppDisplayNameDeviceDisplayNameProfileTagLangAppendReceivedArgumentsLock = NSLock()
|
|
private var setPusherIdentifiersKindAppDisplayNameDeviceDisplayNameProfileTagLangAppendUnderlyingReceivedArguments: (identifiers: PusherIdentifiers, kind: PusherKind, appDisplayName: String, deviceDisplayName: String, profileTag: String?, lang: String, append: Bool)?
|
|
open var setPusherIdentifiersKindAppDisplayNameDeviceDisplayNameProfileTagLangAppendReceivedArguments: (identifiers: PusherIdentifiers, kind: PusherKind, appDisplayName: String, deviceDisplayName: String, profileTag: String?, lang: String, append: Bool)? {
|
|
get { setPusherIdentifiersKindAppDisplayNameDeviceDisplayNameProfileTagLangAppendReceivedArgumentsLock.withLock { setPusherIdentifiersKindAppDisplayNameDeviceDisplayNameProfileTagLangAppendUnderlyingReceivedArguments } }
|
|
set { setPusherIdentifiersKindAppDisplayNameDeviceDisplayNameProfileTagLangAppendReceivedArgumentsLock.withLock { setPusherIdentifiersKindAppDisplayNameDeviceDisplayNameProfileTagLangAppendUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let setPusherIdentifiersKindAppDisplayNameDeviceDisplayNameProfileTagLangAppendReceivedInvocationsLock = NSLock()
|
|
private var setPusherIdentifiersKindAppDisplayNameDeviceDisplayNameProfileTagLangAppendUnderlyingReceivedInvocations: [(identifiers: PusherIdentifiers, kind: PusherKind, appDisplayName: String, deviceDisplayName: String, profileTag: String?, lang: String, append: Bool)] = []
|
|
open var setPusherIdentifiersKindAppDisplayNameDeviceDisplayNameProfileTagLangAppendReceivedInvocations: [(identifiers: PusherIdentifiers, kind: PusherKind, appDisplayName: String, deviceDisplayName: String, profileTag: String?, lang: String, append: Bool)] {
|
|
get { setPusherIdentifiersKindAppDisplayNameDeviceDisplayNameProfileTagLangAppendReceivedInvocationsLock.withLock { setPusherIdentifiersKindAppDisplayNameDeviceDisplayNameProfileTagLangAppendUnderlyingReceivedInvocations } }
|
|
set { setPusherIdentifiersKindAppDisplayNameDeviceDisplayNameProfileTagLangAppendReceivedInvocationsLock.withLock { setPusherIdentifiersKindAppDisplayNameDeviceDisplayNameProfileTagLangAppendUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var setPusherIdentifiersKindAppDisplayNameDeviceDisplayNameProfileTagLangAppendClosure: ((PusherIdentifiers, PusherKind, String, String, String?, String, Bool) async throws -> Void)?
|
|
|
|
open override func setPusher(identifiers: PusherIdentifiers, kind: PusherKind, appDisplayName: String, deviceDisplayName: String, profileTag: String?, lang: String, append: Bool) async throws {
|
|
if let error = setPusherIdentifiersKindAppDisplayNameDeviceDisplayNameProfileTagLangAppendThrowableError {
|
|
throw error
|
|
}
|
|
setPusherIdentifiersKindAppDisplayNameDeviceDisplayNameProfileTagLangAppendCallsCountLock.withLock { setPusherIdentifiersKindAppDisplayNameDeviceDisplayNameProfileTagLangAppendUnderlyingCallsCount += 1 }
|
|
setPusherIdentifiersKindAppDisplayNameDeviceDisplayNameProfileTagLangAppendReceivedArguments = (identifiers: identifiers, kind: kind, appDisplayName: appDisplayName, deviceDisplayName: deviceDisplayName, profileTag: profileTag, lang: lang, append: append)
|
|
setPusherIdentifiersKindAppDisplayNameDeviceDisplayNameProfileTagLangAppendReceivedInvocationsLock.withLock { setPusherIdentifiersKindAppDisplayNameDeviceDisplayNameProfileTagLangAppendUnderlyingReceivedInvocations.append((identifiers: identifiers, kind: kind, appDisplayName: appDisplayName, deviceDisplayName: deviceDisplayName, profileTag: profileTag, lang: lang, append: append)) }
|
|
try await setPusherIdentifiersKindAppDisplayNameDeviceDisplayNameProfileTagLangAppendClosure?(identifiers, kind, appDisplayName, deviceDisplayName, profileTag, lang, append)
|
|
}
|
|
|
|
//MARK: - setUtdDelegate
|
|
|
|
open var setUtdDelegateUtdDelegateThrowableError: Error?
|
|
private let setUtdDelegateUtdDelegateCallsCountLock = NSLock()
|
|
private var setUtdDelegateUtdDelegateUnderlyingCallsCount = 0
|
|
open var setUtdDelegateUtdDelegateCallsCount: Int {
|
|
get { setUtdDelegateUtdDelegateCallsCountLock.withLock { setUtdDelegateUtdDelegateUnderlyingCallsCount } }
|
|
set { setUtdDelegateUtdDelegateCallsCountLock.withLock { setUtdDelegateUtdDelegateUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var setUtdDelegateUtdDelegateCalled: Bool {
|
|
return setUtdDelegateUtdDelegateCallsCount > 0
|
|
}
|
|
private let setUtdDelegateUtdDelegateReceivedUtdDelegateLock = NSLock()
|
|
private var setUtdDelegateUtdDelegateUnderlyingReceivedUtdDelegate: UnableToDecryptDelegate?
|
|
open var setUtdDelegateUtdDelegateReceivedUtdDelegate: UnableToDecryptDelegate? {
|
|
get { setUtdDelegateUtdDelegateReceivedUtdDelegateLock.withLock { setUtdDelegateUtdDelegateUnderlyingReceivedUtdDelegate } }
|
|
set { setUtdDelegateUtdDelegateReceivedUtdDelegateLock.withLock { setUtdDelegateUtdDelegateUnderlyingReceivedUtdDelegate = newValue } }
|
|
}
|
|
private let setUtdDelegateUtdDelegateReceivedInvocationsLock = NSLock()
|
|
private var setUtdDelegateUtdDelegateUnderlyingReceivedInvocations: [UnableToDecryptDelegate] = []
|
|
open var setUtdDelegateUtdDelegateReceivedInvocations: [UnableToDecryptDelegate] {
|
|
get { setUtdDelegateUtdDelegateReceivedInvocationsLock.withLock { setUtdDelegateUtdDelegateUnderlyingReceivedInvocations } }
|
|
set { setUtdDelegateUtdDelegateReceivedInvocationsLock.withLock { setUtdDelegateUtdDelegateUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var setUtdDelegateUtdDelegateClosure: ((UnableToDecryptDelegate) async throws -> Void)?
|
|
|
|
open override func setUtdDelegate(utdDelegate: UnableToDecryptDelegate) async throws {
|
|
if let error = setUtdDelegateUtdDelegateThrowableError {
|
|
throw error
|
|
}
|
|
setUtdDelegateUtdDelegateCallsCountLock.withLock { setUtdDelegateUtdDelegateUnderlyingCallsCount += 1 }
|
|
setUtdDelegateUtdDelegateReceivedUtdDelegate = utdDelegate
|
|
setUtdDelegateUtdDelegateReceivedInvocationsLock.withLock { setUtdDelegateUtdDelegateUnderlyingReceivedInvocations.append(utdDelegate) }
|
|
try await setUtdDelegateUtdDelegateClosure?(utdDelegate)
|
|
}
|
|
|
|
//MARK: - slidingSyncVersion
|
|
|
|
private let slidingSyncVersionCallsCountLock = NSLock()
|
|
private var slidingSyncVersionUnderlyingCallsCount = 0
|
|
open var slidingSyncVersionCallsCount: Int {
|
|
get { slidingSyncVersionCallsCountLock.withLock { slidingSyncVersionUnderlyingCallsCount } }
|
|
set { slidingSyncVersionCallsCountLock.withLock { slidingSyncVersionUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var slidingSyncVersionCalled: Bool {
|
|
return slidingSyncVersionCallsCount > 0
|
|
}
|
|
|
|
private let slidingSyncVersionReturnValueLock = NSLock()
|
|
open var slidingSyncVersionUnderlyingReturnValue: SlidingSyncVersion!
|
|
open var slidingSyncVersionReturnValue: SlidingSyncVersion! {
|
|
get { slidingSyncVersionReturnValueLock.withLock { slidingSyncVersionUnderlyingReturnValue } }
|
|
set { slidingSyncVersionReturnValueLock.withLock { slidingSyncVersionUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var slidingSyncVersionClosure: (() -> SlidingSyncVersion)?
|
|
|
|
open override func slidingSyncVersion() -> SlidingSyncVersion {
|
|
slidingSyncVersionCallsCountLock.withLock { slidingSyncVersionUnderlyingCallsCount += 1 }
|
|
if let slidingSyncVersionClosure = slidingSyncVersionClosure {
|
|
return slidingSyncVersionClosure()
|
|
} else {
|
|
return slidingSyncVersionReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - spaceService
|
|
|
|
private let spaceServiceCallsCountLock = NSLock()
|
|
private var spaceServiceUnderlyingCallsCount = 0
|
|
open var spaceServiceCallsCount: Int {
|
|
get { spaceServiceCallsCountLock.withLock { spaceServiceUnderlyingCallsCount } }
|
|
set { spaceServiceCallsCountLock.withLock { spaceServiceUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var spaceServiceCalled: Bool {
|
|
return spaceServiceCallsCount > 0
|
|
}
|
|
|
|
private let spaceServiceReturnValueLock = NSLock()
|
|
open var spaceServiceUnderlyingReturnValue: SpaceService!
|
|
open var spaceServiceReturnValue: SpaceService! {
|
|
get { spaceServiceReturnValueLock.withLock { spaceServiceUnderlyingReturnValue } }
|
|
set { spaceServiceReturnValueLock.withLock { spaceServiceUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var spaceServiceClosure: (() async -> SpaceService)?
|
|
|
|
open override func spaceService() async -> SpaceService {
|
|
spaceServiceCallsCountLock.withLock { spaceServiceUnderlyingCallsCount += 1 }
|
|
if let spaceServiceClosure = spaceServiceClosure {
|
|
return await spaceServiceClosure()
|
|
} else {
|
|
return spaceServiceReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - startSsoLogin
|
|
|
|
open var startSsoLoginRedirectUrlIdpIdThrowableError: Error?
|
|
private let startSsoLoginRedirectUrlIdpIdCallsCountLock = NSLock()
|
|
private var startSsoLoginRedirectUrlIdpIdUnderlyingCallsCount = 0
|
|
open var startSsoLoginRedirectUrlIdpIdCallsCount: Int {
|
|
get { startSsoLoginRedirectUrlIdpIdCallsCountLock.withLock { startSsoLoginRedirectUrlIdpIdUnderlyingCallsCount } }
|
|
set { startSsoLoginRedirectUrlIdpIdCallsCountLock.withLock { startSsoLoginRedirectUrlIdpIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var startSsoLoginRedirectUrlIdpIdCalled: Bool {
|
|
return startSsoLoginRedirectUrlIdpIdCallsCount > 0
|
|
}
|
|
private let startSsoLoginRedirectUrlIdpIdReceivedArgumentsLock = NSLock()
|
|
private var startSsoLoginRedirectUrlIdpIdUnderlyingReceivedArguments: (redirectUrl: String, idpId: String?)?
|
|
open var startSsoLoginRedirectUrlIdpIdReceivedArguments: (redirectUrl: String, idpId: String?)? {
|
|
get { startSsoLoginRedirectUrlIdpIdReceivedArgumentsLock.withLock { startSsoLoginRedirectUrlIdpIdUnderlyingReceivedArguments } }
|
|
set { startSsoLoginRedirectUrlIdpIdReceivedArgumentsLock.withLock { startSsoLoginRedirectUrlIdpIdUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let startSsoLoginRedirectUrlIdpIdReceivedInvocationsLock = NSLock()
|
|
private var startSsoLoginRedirectUrlIdpIdUnderlyingReceivedInvocations: [(redirectUrl: String, idpId: String?)] = []
|
|
open var startSsoLoginRedirectUrlIdpIdReceivedInvocations: [(redirectUrl: String, idpId: String?)] {
|
|
get { startSsoLoginRedirectUrlIdpIdReceivedInvocationsLock.withLock { startSsoLoginRedirectUrlIdpIdUnderlyingReceivedInvocations } }
|
|
set { startSsoLoginRedirectUrlIdpIdReceivedInvocationsLock.withLock { startSsoLoginRedirectUrlIdpIdUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let startSsoLoginRedirectUrlIdpIdReturnValueLock = NSLock()
|
|
open var startSsoLoginRedirectUrlIdpIdUnderlyingReturnValue: SsoHandler!
|
|
open var startSsoLoginRedirectUrlIdpIdReturnValue: SsoHandler! {
|
|
get { startSsoLoginRedirectUrlIdpIdReturnValueLock.withLock { startSsoLoginRedirectUrlIdpIdUnderlyingReturnValue } }
|
|
set { startSsoLoginRedirectUrlIdpIdReturnValueLock.withLock { startSsoLoginRedirectUrlIdpIdUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var startSsoLoginRedirectUrlIdpIdClosure: ((String, String?) async throws -> SsoHandler)?
|
|
|
|
open override func startSsoLogin(redirectUrl: String, idpId: String?) async throws -> SsoHandler {
|
|
if let error = startSsoLoginRedirectUrlIdpIdThrowableError {
|
|
throw error
|
|
}
|
|
startSsoLoginRedirectUrlIdpIdCallsCountLock.withLock { startSsoLoginRedirectUrlIdpIdUnderlyingCallsCount += 1 }
|
|
startSsoLoginRedirectUrlIdpIdReceivedArguments = (redirectUrl: redirectUrl, idpId: idpId)
|
|
startSsoLoginRedirectUrlIdpIdReceivedInvocationsLock.withLock { startSsoLoginRedirectUrlIdpIdUnderlyingReceivedInvocations.append((redirectUrl: redirectUrl, idpId: idpId)) }
|
|
if let startSsoLoginRedirectUrlIdpIdClosure = startSsoLoginRedirectUrlIdpIdClosure {
|
|
return try await startSsoLoginRedirectUrlIdpIdClosure(redirectUrl, idpId)
|
|
} else {
|
|
return startSsoLoginRedirectUrlIdpIdReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - subscribeToDuplicateKeyUploadErrors
|
|
|
|
private let subscribeToDuplicateKeyUploadErrorsListenerCallsCountLock = NSLock()
|
|
private var subscribeToDuplicateKeyUploadErrorsListenerUnderlyingCallsCount = 0
|
|
open var subscribeToDuplicateKeyUploadErrorsListenerCallsCount: Int {
|
|
get { subscribeToDuplicateKeyUploadErrorsListenerCallsCountLock.withLock { subscribeToDuplicateKeyUploadErrorsListenerUnderlyingCallsCount } }
|
|
set { subscribeToDuplicateKeyUploadErrorsListenerCallsCountLock.withLock { subscribeToDuplicateKeyUploadErrorsListenerUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var subscribeToDuplicateKeyUploadErrorsListenerCalled: Bool {
|
|
return subscribeToDuplicateKeyUploadErrorsListenerCallsCount > 0
|
|
}
|
|
private let subscribeToDuplicateKeyUploadErrorsListenerReceivedListenerLock = NSLock()
|
|
private var subscribeToDuplicateKeyUploadErrorsListenerUnderlyingReceivedListener: DuplicateKeyUploadErrorListener?
|
|
open var subscribeToDuplicateKeyUploadErrorsListenerReceivedListener: DuplicateKeyUploadErrorListener? {
|
|
get { subscribeToDuplicateKeyUploadErrorsListenerReceivedListenerLock.withLock { subscribeToDuplicateKeyUploadErrorsListenerUnderlyingReceivedListener } }
|
|
set { subscribeToDuplicateKeyUploadErrorsListenerReceivedListenerLock.withLock { subscribeToDuplicateKeyUploadErrorsListenerUnderlyingReceivedListener = newValue } }
|
|
}
|
|
private let subscribeToDuplicateKeyUploadErrorsListenerReceivedInvocationsLock = NSLock()
|
|
private var subscribeToDuplicateKeyUploadErrorsListenerUnderlyingReceivedInvocations: [DuplicateKeyUploadErrorListener] = []
|
|
open var subscribeToDuplicateKeyUploadErrorsListenerReceivedInvocations: [DuplicateKeyUploadErrorListener] {
|
|
get { subscribeToDuplicateKeyUploadErrorsListenerReceivedInvocationsLock.withLock { subscribeToDuplicateKeyUploadErrorsListenerUnderlyingReceivedInvocations } }
|
|
set { subscribeToDuplicateKeyUploadErrorsListenerReceivedInvocationsLock.withLock { subscribeToDuplicateKeyUploadErrorsListenerUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let subscribeToDuplicateKeyUploadErrorsListenerReturnValueLock = NSLock()
|
|
open var subscribeToDuplicateKeyUploadErrorsListenerUnderlyingReturnValue: TaskHandle!
|
|
open var subscribeToDuplicateKeyUploadErrorsListenerReturnValue: TaskHandle! {
|
|
get { subscribeToDuplicateKeyUploadErrorsListenerReturnValueLock.withLock { subscribeToDuplicateKeyUploadErrorsListenerUnderlyingReturnValue } }
|
|
set { subscribeToDuplicateKeyUploadErrorsListenerReturnValueLock.withLock { subscribeToDuplicateKeyUploadErrorsListenerUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var subscribeToDuplicateKeyUploadErrorsListenerClosure: ((DuplicateKeyUploadErrorListener) -> TaskHandle)?
|
|
|
|
open override func subscribeToDuplicateKeyUploadErrors(listener: DuplicateKeyUploadErrorListener) -> TaskHandle {
|
|
subscribeToDuplicateKeyUploadErrorsListenerCallsCountLock.withLock { subscribeToDuplicateKeyUploadErrorsListenerUnderlyingCallsCount += 1 }
|
|
subscribeToDuplicateKeyUploadErrorsListenerReceivedListener = listener
|
|
subscribeToDuplicateKeyUploadErrorsListenerReceivedInvocationsLock.withLock { subscribeToDuplicateKeyUploadErrorsListenerUnderlyingReceivedInvocations.append(listener) }
|
|
if let subscribeToDuplicateKeyUploadErrorsListenerClosure = subscribeToDuplicateKeyUploadErrorsListenerClosure {
|
|
return subscribeToDuplicateKeyUploadErrorsListenerClosure(listener)
|
|
} else {
|
|
return subscribeToDuplicateKeyUploadErrorsListenerReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - subscribeToIgnoredUsers
|
|
|
|
private let subscribeToIgnoredUsersListenerCallsCountLock = NSLock()
|
|
private var subscribeToIgnoredUsersListenerUnderlyingCallsCount = 0
|
|
open var subscribeToIgnoredUsersListenerCallsCount: Int {
|
|
get { subscribeToIgnoredUsersListenerCallsCountLock.withLock { subscribeToIgnoredUsersListenerUnderlyingCallsCount } }
|
|
set { subscribeToIgnoredUsersListenerCallsCountLock.withLock { subscribeToIgnoredUsersListenerUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var subscribeToIgnoredUsersListenerCalled: Bool {
|
|
return subscribeToIgnoredUsersListenerCallsCount > 0
|
|
}
|
|
private let subscribeToIgnoredUsersListenerReceivedListenerLock = NSLock()
|
|
private var subscribeToIgnoredUsersListenerUnderlyingReceivedListener: IgnoredUsersListener?
|
|
open var subscribeToIgnoredUsersListenerReceivedListener: IgnoredUsersListener? {
|
|
get { subscribeToIgnoredUsersListenerReceivedListenerLock.withLock { subscribeToIgnoredUsersListenerUnderlyingReceivedListener } }
|
|
set { subscribeToIgnoredUsersListenerReceivedListenerLock.withLock { subscribeToIgnoredUsersListenerUnderlyingReceivedListener = newValue } }
|
|
}
|
|
private let subscribeToIgnoredUsersListenerReceivedInvocationsLock = NSLock()
|
|
private var subscribeToIgnoredUsersListenerUnderlyingReceivedInvocations: [IgnoredUsersListener] = []
|
|
open var subscribeToIgnoredUsersListenerReceivedInvocations: [IgnoredUsersListener] {
|
|
get { subscribeToIgnoredUsersListenerReceivedInvocationsLock.withLock { subscribeToIgnoredUsersListenerUnderlyingReceivedInvocations } }
|
|
set { subscribeToIgnoredUsersListenerReceivedInvocationsLock.withLock { subscribeToIgnoredUsersListenerUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let subscribeToIgnoredUsersListenerReturnValueLock = NSLock()
|
|
open var subscribeToIgnoredUsersListenerUnderlyingReturnValue: TaskHandle!
|
|
open var subscribeToIgnoredUsersListenerReturnValue: TaskHandle! {
|
|
get { subscribeToIgnoredUsersListenerReturnValueLock.withLock { subscribeToIgnoredUsersListenerUnderlyingReturnValue } }
|
|
set { subscribeToIgnoredUsersListenerReturnValueLock.withLock { subscribeToIgnoredUsersListenerUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var subscribeToIgnoredUsersListenerClosure: ((IgnoredUsersListener) -> TaskHandle)?
|
|
|
|
open override func subscribeToIgnoredUsers(listener: IgnoredUsersListener) -> TaskHandle {
|
|
subscribeToIgnoredUsersListenerCallsCountLock.withLock { subscribeToIgnoredUsersListenerUnderlyingCallsCount += 1 }
|
|
subscribeToIgnoredUsersListenerReceivedListener = listener
|
|
subscribeToIgnoredUsersListenerReceivedInvocationsLock.withLock { subscribeToIgnoredUsersListenerUnderlyingReceivedInvocations.append(listener) }
|
|
if let subscribeToIgnoredUsersListenerClosure = subscribeToIgnoredUsersListenerClosure {
|
|
return subscribeToIgnoredUsersListenerClosure(listener)
|
|
} else {
|
|
return subscribeToIgnoredUsersListenerReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - subscribeToMediaPreviewConfig
|
|
|
|
open var subscribeToMediaPreviewConfigListenerThrowableError: Error?
|
|
private let subscribeToMediaPreviewConfigListenerCallsCountLock = NSLock()
|
|
private var subscribeToMediaPreviewConfigListenerUnderlyingCallsCount = 0
|
|
open var subscribeToMediaPreviewConfigListenerCallsCount: Int {
|
|
get { subscribeToMediaPreviewConfigListenerCallsCountLock.withLock { subscribeToMediaPreviewConfigListenerUnderlyingCallsCount } }
|
|
set { subscribeToMediaPreviewConfigListenerCallsCountLock.withLock { subscribeToMediaPreviewConfigListenerUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var subscribeToMediaPreviewConfigListenerCalled: Bool {
|
|
return subscribeToMediaPreviewConfigListenerCallsCount > 0
|
|
}
|
|
private let subscribeToMediaPreviewConfigListenerReceivedListenerLock = NSLock()
|
|
private var subscribeToMediaPreviewConfigListenerUnderlyingReceivedListener: MediaPreviewConfigListener?
|
|
open var subscribeToMediaPreviewConfigListenerReceivedListener: MediaPreviewConfigListener? {
|
|
get { subscribeToMediaPreviewConfigListenerReceivedListenerLock.withLock { subscribeToMediaPreviewConfigListenerUnderlyingReceivedListener } }
|
|
set { subscribeToMediaPreviewConfigListenerReceivedListenerLock.withLock { subscribeToMediaPreviewConfigListenerUnderlyingReceivedListener = newValue } }
|
|
}
|
|
private let subscribeToMediaPreviewConfigListenerReceivedInvocationsLock = NSLock()
|
|
private var subscribeToMediaPreviewConfigListenerUnderlyingReceivedInvocations: [MediaPreviewConfigListener] = []
|
|
open var subscribeToMediaPreviewConfigListenerReceivedInvocations: [MediaPreviewConfigListener] {
|
|
get { subscribeToMediaPreviewConfigListenerReceivedInvocationsLock.withLock { subscribeToMediaPreviewConfigListenerUnderlyingReceivedInvocations } }
|
|
set { subscribeToMediaPreviewConfigListenerReceivedInvocationsLock.withLock { subscribeToMediaPreviewConfigListenerUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let subscribeToMediaPreviewConfigListenerReturnValueLock = NSLock()
|
|
open var subscribeToMediaPreviewConfigListenerUnderlyingReturnValue: TaskHandle!
|
|
open var subscribeToMediaPreviewConfigListenerReturnValue: TaskHandle! {
|
|
get { subscribeToMediaPreviewConfigListenerReturnValueLock.withLock { subscribeToMediaPreviewConfigListenerUnderlyingReturnValue } }
|
|
set { subscribeToMediaPreviewConfigListenerReturnValueLock.withLock { subscribeToMediaPreviewConfigListenerUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var subscribeToMediaPreviewConfigListenerClosure: ((MediaPreviewConfigListener) async throws -> TaskHandle)?
|
|
|
|
open override func subscribeToMediaPreviewConfig(listener: MediaPreviewConfigListener) async throws -> TaskHandle {
|
|
if let error = subscribeToMediaPreviewConfigListenerThrowableError {
|
|
throw error
|
|
}
|
|
subscribeToMediaPreviewConfigListenerCallsCountLock.withLock { subscribeToMediaPreviewConfigListenerUnderlyingCallsCount += 1 }
|
|
subscribeToMediaPreviewConfigListenerReceivedListener = listener
|
|
subscribeToMediaPreviewConfigListenerReceivedInvocationsLock.withLock { subscribeToMediaPreviewConfigListenerUnderlyingReceivedInvocations.append(listener) }
|
|
if let subscribeToMediaPreviewConfigListenerClosure = subscribeToMediaPreviewConfigListenerClosure {
|
|
return try await subscribeToMediaPreviewConfigListenerClosure(listener)
|
|
} else {
|
|
return subscribeToMediaPreviewConfigListenerReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - subscribeToOwnBeaconInfoUpdates
|
|
|
|
open var subscribeToOwnBeaconInfoUpdatesListenerThrowableError: Error?
|
|
private let subscribeToOwnBeaconInfoUpdatesListenerCallsCountLock = NSLock()
|
|
private var subscribeToOwnBeaconInfoUpdatesListenerUnderlyingCallsCount = 0
|
|
open var subscribeToOwnBeaconInfoUpdatesListenerCallsCount: Int {
|
|
get { subscribeToOwnBeaconInfoUpdatesListenerCallsCountLock.withLock { subscribeToOwnBeaconInfoUpdatesListenerUnderlyingCallsCount } }
|
|
set { subscribeToOwnBeaconInfoUpdatesListenerCallsCountLock.withLock { subscribeToOwnBeaconInfoUpdatesListenerUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var subscribeToOwnBeaconInfoUpdatesListenerCalled: Bool {
|
|
return subscribeToOwnBeaconInfoUpdatesListenerCallsCount > 0
|
|
}
|
|
private let subscribeToOwnBeaconInfoUpdatesListenerReceivedListenerLock = NSLock()
|
|
private var subscribeToOwnBeaconInfoUpdatesListenerUnderlyingReceivedListener: BeaconInfoListener?
|
|
open var subscribeToOwnBeaconInfoUpdatesListenerReceivedListener: BeaconInfoListener? {
|
|
get { subscribeToOwnBeaconInfoUpdatesListenerReceivedListenerLock.withLock { subscribeToOwnBeaconInfoUpdatesListenerUnderlyingReceivedListener } }
|
|
set { subscribeToOwnBeaconInfoUpdatesListenerReceivedListenerLock.withLock { subscribeToOwnBeaconInfoUpdatesListenerUnderlyingReceivedListener = newValue } }
|
|
}
|
|
private let subscribeToOwnBeaconInfoUpdatesListenerReceivedInvocationsLock = NSLock()
|
|
private var subscribeToOwnBeaconInfoUpdatesListenerUnderlyingReceivedInvocations: [BeaconInfoListener] = []
|
|
open var subscribeToOwnBeaconInfoUpdatesListenerReceivedInvocations: [BeaconInfoListener] {
|
|
get { subscribeToOwnBeaconInfoUpdatesListenerReceivedInvocationsLock.withLock { subscribeToOwnBeaconInfoUpdatesListenerUnderlyingReceivedInvocations } }
|
|
set { subscribeToOwnBeaconInfoUpdatesListenerReceivedInvocationsLock.withLock { subscribeToOwnBeaconInfoUpdatesListenerUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let subscribeToOwnBeaconInfoUpdatesListenerReturnValueLock = NSLock()
|
|
open var subscribeToOwnBeaconInfoUpdatesListenerUnderlyingReturnValue: TaskHandle!
|
|
open var subscribeToOwnBeaconInfoUpdatesListenerReturnValue: TaskHandle! {
|
|
get { subscribeToOwnBeaconInfoUpdatesListenerReturnValueLock.withLock { subscribeToOwnBeaconInfoUpdatesListenerUnderlyingReturnValue } }
|
|
set { subscribeToOwnBeaconInfoUpdatesListenerReturnValueLock.withLock { subscribeToOwnBeaconInfoUpdatesListenerUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var subscribeToOwnBeaconInfoUpdatesListenerClosure: ((BeaconInfoListener) throws -> TaskHandle)?
|
|
|
|
open override func subscribeToOwnBeaconInfoUpdates(listener: BeaconInfoListener) throws -> TaskHandle {
|
|
if let error = subscribeToOwnBeaconInfoUpdatesListenerThrowableError {
|
|
throw error
|
|
}
|
|
subscribeToOwnBeaconInfoUpdatesListenerCallsCountLock.withLock { subscribeToOwnBeaconInfoUpdatesListenerUnderlyingCallsCount += 1 }
|
|
subscribeToOwnBeaconInfoUpdatesListenerReceivedListener = listener
|
|
subscribeToOwnBeaconInfoUpdatesListenerReceivedInvocationsLock.withLock { subscribeToOwnBeaconInfoUpdatesListenerUnderlyingReceivedInvocations.append(listener) }
|
|
if let subscribeToOwnBeaconInfoUpdatesListenerClosure = subscribeToOwnBeaconInfoUpdatesListenerClosure {
|
|
return try subscribeToOwnBeaconInfoUpdatesListenerClosure(listener)
|
|
} else {
|
|
return subscribeToOwnBeaconInfoUpdatesListenerReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - subscribeToRoomInfo
|
|
|
|
open var subscribeToRoomInfoRoomIdListenerThrowableError: Error?
|
|
private let subscribeToRoomInfoRoomIdListenerCallsCountLock = NSLock()
|
|
private var subscribeToRoomInfoRoomIdListenerUnderlyingCallsCount = 0
|
|
open var subscribeToRoomInfoRoomIdListenerCallsCount: Int {
|
|
get { subscribeToRoomInfoRoomIdListenerCallsCountLock.withLock { subscribeToRoomInfoRoomIdListenerUnderlyingCallsCount } }
|
|
set { subscribeToRoomInfoRoomIdListenerCallsCountLock.withLock { subscribeToRoomInfoRoomIdListenerUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var subscribeToRoomInfoRoomIdListenerCalled: Bool {
|
|
return subscribeToRoomInfoRoomIdListenerCallsCount > 0
|
|
}
|
|
private let subscribeToRoomInfoRoomIdListenerReceivedArgumentsLock = NSLock()
|
|
private var subscribeToRoomInfoRoomIdListenerUnderlyingReceivedArguments: (roomId: String, listener: RoomInfoListener)?
|
|
open var subscribeToRoomInfoRoomIdListenerReceivedArguments: (roomId: String, listener: RoomInfoListener)? {
|
|
get { subscribeToRoomInfoRoomIdListenerReceivedArgumentsLock.withLock { subscribeToRoomInfoRoomIdListenerUnderlyingReceivedArguments } }
|
|
set { subscribeToRoomInfoRoomIdListenerReceivedArgumentsLock.withLock { subscribeToRoomInfoRoomIdListenerUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let subscribeToRoomInfoRoomIdListenerReceivedInvocationsLock = NSLock()
|
|
private var subscribeToRoomInfoRoomIdListenerUnderlyingReceivedInvocations: [(roomId: String, listener: RoomInfoListener)] = []
|
|
open var subscribeToRoomInfoRoomIdListenerReceivedInvocations: [(roomId: String, listener: RoomInfoListener)] {
|
|
get { subscribeToRoomInfoRoomIdListenerReceivedInvocationsLock.withLock { subscribeToRoomInfoRoomIdListenerUnderlyingReceivedInvocations } }
|
|
set { subscribeToRoomInfoRoomIdListenerReceivedInvocationsLock.withLock { subscribeToRoomInfoRoomIdListenerUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let subscribeToRoomInfoRoomIdListenerReturnValueLock = NSLock()
|
|
open var subscribeToRoomInfoRoomIdListenerUnderlyingReturnValue: TaskHandle!
|
|
open var subscribeToRoomInfoRoomIdListenerReturnValue: TaskHandle! {
|
|
get { subscribeToRoomInfoRoomIdListenerReturnValueLock.withLock { subscribeToRoomInfoRoomIdListenerUnderlyingReturnValue } }
|
|
set { subscribeToRoomInfoRoomIdListenerReturnValueLock.withLock { subscribeToRoomInfoRoomIdListenerUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var subscribeToRoomInfoRoomIdListenerClosure: ((String, RoomInfoListener) async throws -> TaskHandle)?
|
|
|
|
open override func subscribeToRoomInfo(roomId: String, listener: RoomInfoListener) async throws -> TaskHandle {
|
|
if let error = subscribeToRoomInfoRoomIdListenerThrowableError {
|
|
throw error
|
|
}
|
|
subscribeToRoomInfoRoomIdListenerCallsCountLock.withLock { subscribeToRoomInfoRoomIdListenerUnderlyingCallsCount += 1 }
|
|
subscribeToRoomInfoRoomIdListenerReceivedArguments = (roomId: roomId, listener: listener)
|
|
subscribeToRoomInfoRoomIdListenerReceivedInvocationsLock.withLock { subscribeToRoomInfoRoomIdListenerUnderlyingReceivedInvocations.append((roomId: roomId, listener: listener)) }
|
|
if let subscribeToRoomInfoRoomIdListenerClosure = subscribeToRoomInfoRoomIdListenerClosure {
|
|
return try await subscribeToRoomInfoRoomIdListenerClosure(roomId, listener)
|
|
} else {
|
|
return subscribeToRoomInfoRoomIdListenerReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - subscribeToSendQueueStatus
|
|
|
|
private let subscribeToSendQueueStatusListenerCallsCountLock = NSLock()
|
|
private var subscribeToSendQueueStatusListenerUnderlyingCallsCount = 0
|
|
open var subscribeToSendQueueStatusListenerCallsCount: Int {
|
|
get { subscribeToSendQueueStatusListenerCallsCountLock.withLock { subscribeToSendQueueStatusListenerUnderlyingCallsCount } }
|
|
set { subscribeToSendQueueStatusListenerCallsCountLock.withLock { subscribeToSendQueueStatusListenerUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var subscribeToSendQueueStatusListenerCalled: Bool {
|
|
return subscribeToSendQueueStatusListenerCallsCount > 0
|
|
}
|
|
private let subscribeToSendQueueStatusListenerReceivedListenerLock = NSLock()
|
|
private var subscribeToSendQueueStatusListenerUnderlyingReceivedListener: SendQueueRoomErrorListener?
|
|
open var subscribeToSendQueueStatusListenerReceivedListener: SendQueueRoomErrorListener? {
|
|
get { subscribeToSendQueueStatusListenerReceivedListenerLock.withLock { subscribeToSendQueueStatusListenerUnderlyingReceivedListener } }
|
|
set { subscribeToSendQueueStatusListenerReceivedListenerLock.withLock { subscribeToSendQueueStatusListenerUnderlyingReceivedListener = newValue } }
|
|
}
|
|
private let subscribeToSendQueueStatusListenerReceivedInvocationsLock = NSLock()
|
|
private var subscribeToSendQueueStatusListenerUnderlyingReceivedInvocations: [SendQueueRoomErrorListener] = []
|
|
open var subscribeToSendQueueStatusListenerReceivedInvocations: [SendQueueRoomErrorListener] {
|
|
get { subscribeToSendQueueStatusListenerReceivedInvocationsLock.withLock { subscribeToSendQueueStatusListenerUnderlyingReceivedInvocations } }
|
|
set { subscribeToSendQueueStatusListenerReceivedInvocationsLock.withLock { subscribeToSendQueueStatusListenerUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let subscribeToSendQueueStatusListenerReturnValueLock = NSLock()
|
|
open var subscribeToSendQueueStatusListenerUnderlyingReturnValue: TaskHandle!
|
|
open var subscribeToSendQueueStatusListenerReturnValue: TaskHandle! {
|
|
get { subscribeToSendQueueStatusListenerReturnValueLock.withLock { subscribeToSendQueueStatusListenerUnderlyingReturnValue } }
|
|
set { subscribeToSendQueueStatusListenerReturnValueLock.withLock { subscribeToSendQueueStatusListenerUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var subscribeToSendQueueStatusListenerClosure: ((SendQueueRoomErrorListener) -> TaskHandle)?
|
|
|
|
open override func subscribeToSendQueueStatus(listener: SendQueueRoomErrorListener) -> TaskHandle {
|
|
subscribeToSendQueueStatusListenerCallsCountLock.withLock { subscribeToSendQueueStatusListenerUnderlyingCallsCount += 1 }
|
|
subscribeToSendQueueStatusListenerReceivedListener = listener
|
|
subscribeToSendQueueStatusListenerReceivedInvocationsLock.withLock { subscribeToSendQueueStatusListenerUnderlyingReceivedInvocations.append(listener) }
|
|
if let subscribeToSendQueueStatusListenerClosure = subscribeToSendQueueStatusListenerClosure {
|
|
return subscribeToSendQueueStatusListenerClosure(listener)
|
|
} else {
|
|
return subscribeToSendQueueStatusListenerReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - subscribeToSendQueueUpdates
|
|
|
|
open var subscribeToSendQueueUpdatesListenerThrowableError: Error?
|
|
private let subscribeToSendQueueUpdatesListenerCallsCountLock = NSLock()
|
|
private var subscribeToSendQueueUpdatesListenerUnderlyingCallsCount = 0
|
|
open var subscribeToSendQueueUpdatesListenerCallsCount: Int {
|
|
get { subscribeToSendQueueUpdatesListenerCallsCountLock.withLock { subscribeToSendQueueUpdatesListenerUnderlyingCallsCount } }
|
|
set { subscribeToSendQueueUpdatesListenerCallsCountLock.withLock { subscribeToSendQueueUpdatesListenerUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var subscribeToSendQueueUpdatesListenerCalled: Bool {
|
|
return subscribeToSendQueueUpdatesListenerCallsCount > 0
|
|
}
|
|
private let subscribeToSendQueueUpdatesListenerReceivedListenerLock = NSLock()
|
|
private var subscribeToSendQueueUpdatesListenerUnderlyingReceivedListener: SendQueueRoomUpdateListener?
|
|
open var subscribeToSendQueueUpdatesListenerReceivedListener: SendQueueRoomUpdateListener? {
|
|
get { subscribeToSendQueueUpdatesListenerReceivedListenerLock.withLock { subscribeToSendQueueUpdatesListenerUnderlyingReceivedListener } }
|
|
set { subscribeToSendQueueUpdatesListenerReceivedListenerLock.withLock { subscribeToSendQueueUpdatesListenerUnderlyingReceivedListener = newValue } }
|
|
}
|
|
private let subscribeToSendQueueUpdatesListenerReceivedInvocationsLock = NSLock()
|
|
private var subscribeToSendQueueUpdatesListenerUnderlyingReceivedInvocations: [SendQueueRoomUpdateListener] = []
|
|
open var subscribeToSendQueueUpdatesListenerReceivedInvocations: [SendQueueRoomUpdateListener] {
|
|
get { subscribeToSendQueueUpdatesListenerReceivedInvocationsLock.withLock { subscribeToSendQueueUpdatesListenerUnderlyingReceivedInvocations } }
|
|
set { subscribeToSendQueueUpdatesListenerReceivedInvocationsLock.withLock { subscribeToSendQueueUpdatesListenerUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let subscribeToSendQueueUpdatesListenerReturnValueLock = NSLock()
|
|
open var subscribeToSendQueueUpdatesListenerUnderlyingReturnValue: TaskHandle!
|
|
open var subscribeToSendQueueUpdatesListenerReturnValue: TaskHandle! {
|
|
get { subscribeToSendQueueUpdatesListenerReturnValueLock.withLock { subscribeToSendQueueUpdatesListenerUnderlyingReturnValue } }
|
|
set { subscribeToSendQueueUpdatesListenerReturnValueLock.withLock { subscribeToSendQueueUpdatesListenerUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var subscribeToSendQueueUpdatesListenerClosure: ((SendQueueRoomUpdateListener) async throws -> TaskHandle)?
|
|
|
|
open override func subscribeToSendQueueUpdates(listener: SendQueueRoomUpdateListener) async throws -> TaskHandle {
|
|
if let error = subscribeToSendQueueUpdatesListenerThrowableError {
|
|
throw error
|
|
}
|
|
subscribeToSendQueueUpdatesListenerCallsCountLock.withLock { subscribeToSendQueueUpdatesListenerUnderlyingCallsCount += 1 }
|
|
subscribeToSendQueueUpdatesListenerReceivedListener = listener
|
|
subscribeToSendQueueUpdatesListenerReceivedInvocationsLock.withLock { subscribeToSendQueueUpdatesListenerUnderlyingReceivedInvocations.append(listener) }
|
|
if let subscribeToSendQueueUpdatesListenerClosure = subscribeToSendQueueUpdatesListenerClosure {
|
|
return try await subscribeToSendQueueUpdatesListenerClosure(listener)
|
|
} else {
|
|
return subscribeToSendQueueUpdatesListenerReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - syncOnceV2
|
|
|
|
open var syncOnceV2SettingsThrowableError: Error?
|
|
private let syncOnceV2SettingsCallsCountLock = NSLock()
|
|
private var syncOnceV2SettingsUnderlyingCallsCount = 0
|
|
open var syncOnceV2SettingsCallsCount: Int {
|
|
get { syncOnceV2SettingsCallsCountLock.withLock { syncOnceV2SettingsUnderlyingCallsCount } }
|
|
set { syncOnceV2SettingsCallsCountLock.withLock { syncOnceV2SettingsUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var syncOnceV2SettingsCalled: Bool {
|
|
return syncOnceV2SettingsCallsCount > 0
|
|
}
|
|
private let syncOnceV2SettingsReceivedSettingsLock = NSLock()
|
|
private var syncOnceV2SettingsUnderlyingReceivedSettings: SyncSettingsV2?
|
|
open var syncOnceV2SettingsReceivedSettings: SyncSettingsV2? {
|
|
get { syncOnceV2SettingsReceivedSettingsLock.withLock { syncOnceV2SettingsUnderlyingReceivedSettings } }
|
|
set { syncOnceV2SettingsReceivedSettingsLock.withLock { syncOnceV2SettingsUnderlyingReceivedSettings = newValue } }
|
|
}
|
|
private let syncOnceV2SettingsReceivedInvocationsLock = NSLock()
|
|
private var syncOnceV2SettingsUnderlyingReceivedInvocations: [SyncSettingsV2] = []
|
|
open var syncOnceV2SettingsReceivedInvocations: [SyncSettingsV2] {
|
|
get { syncOnceV2SettingsReceivedInvocationsLock.withLock { syncOnceV2SettingsUnderlyingReceivedInvocations } }
|
|
set { syncOnceV2SettingsReceivedInvocationsLock.withLock { syncOnceV2SettingsUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let syncOnceV2SettingsReturnValueLock = NSLock()
|
|
open var syncOnceV2SettingsUnderlyingReturnValue: SyncResponseV2!
|
|
open var syncOnceV2SettingsReturnValue: SyncResponseV2! {
|
|
get { syncOnceV2SettingsReturnValueLock.withLock { syncOnceV2SettingsUnderlyingReturnValue } }
|
|
set { syncOnceV2SettingsReturnValueLock.withLock { syncOnceV2SettingsUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var syncOnceV2SettingsClosure: ((SyncSettingsV2) async throws -> SyncResponseV2)?
|
|
|
|
open override func syncOnceV2(settings: SyncSettingsV2) async throws -> SyncResponseV2 {
|
|
if let error = syncOnceV2SettingsThrowableError {
|
|
throw error
|
|
}
|
|
syncOnceV2SettingsCallsCountLock.withLock { syncOnceV2SettingsUnderlyingCallsCount += 1 }
|
|
syncOnceV2SettingsReceivedSettings = settings
|
|
syncOnceV2SettingsReceivedInvocationsLock.withLock { syncOnceV2SettingsUnderlyingReceivedInvocations.append(settings) }
|
|
if let syncOnceV2SettingsClosure = syncOnceV2SettingsClosure {
|
|
return try await syncOnceV2SettingsClosure(settings)
|
|
} else {
|
|
return syncOnceV2SettingsReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - syncService
|
|
|
|
private let syncServiceCallsCountLock = NSLock()
|
|
private var syncServiceUnderlyingCallsCount = 0
|
|
open var syncServiceCallsCount: Int {
|
|
get { syncServiceCallsCountLock.withLock { syncServiceUnderlyingCallsCount } }
|
|
set { syncServiceCallsCountLock.withLock { syncServiceUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var syncServiceCalled: Bool {
|
|
return syncServiceCallsCount > 0
|
|
}
|
|
|
|
private let syncServiceReturnValueLock = NSLock()
|
|
open var syncServiceUnderlyingReturnValue: SyncServiceBuilder!
|
|
open var syncServiceReturnValue: SyncServiceBuilder! {
|
|
get { syncServiceReturnValueLock.withLock { syncServiceUnderlyingReturnValue } }
|
|
set { syncServiceReturnValueLock.withLock { syncServiceUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var syncServiceClosure: (() -> SyncServiceBuilder)?
|
|
|
|
open override func syncService() -> SyncServiceBuilder {
|
|
syncServiceCallsCountLock.withLock { syncServiceUnderlyingCallsCount += 1 }
|
|
if let syncServiceClosure = syncServiceClosure {
|
|
return syncServiceClosure()
|
|
} else {
|
|
return syncServiceReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - syncV2
|
|
|
|
private let syncV2SettingsListenerCallsCountLock = NSLock()
|
|
private var syncV2SettingsListenerUnderlyingCallsCount = 0
|
|
open var syncV2SettingsListenerCallsCount: Int {
|
|
get { syncV2SettingsListenerCallsCountLock.withLock { syncV2SettingsListenerUnderlyingCallsCount } }
|
|
set { syncV2SettingsListenerCallsCountLock.withLock { syncV2SettingsListenerUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var syncV2SettingsListenerCalled: Bool {
|
|
return syncV2SettingsListenerCallsCount > 0
|
|
}
|
|
private let syncV2SettingsListenerReceivedArgumentsLock = NSLock()
|
|
private var syncV2SettingsListenerUnderlyingReceivedArguments: (settings: SyncSettingsV2, listener: SyncListenerV2)?
|
|
open var syncV2SettingsListenerReceivedArguments: (settings: SyncSettingsV2, listener: SyncListenerV2)? {
|
|
get { syncV2SettingsListenerReceivedArgumentsLock.withLock { syncV2SettingsListenerUnderlyingReceivedArguments } }
|
|
set { syncV2SettingsListenerReceivedArgumentsLock.withLock { syncV2SettingsListenerUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let syncV2SettingsListenerReceivedInvocationsLock = NSLock()
|
|
private var syncV2SettingsListenerUnderlyingReceivedInvocations: [(settings: SyncSettingsV2, listener: SyncListenerV2)] = []
|
|
open var syncV2SettingsListenerReceivedInvocations: [(settings: SyncSettingsV2, listener: SyncListenerV2)] {
|
|
get { syncV2SettingsListenerReceivedInvocationsLock.withLock { syncV2SettingsListenerUnderlyingReceivedInvocations } }
|
|
set { syncV2SettingsListenerReceivedInvocationsLock.withLock { syncV2SettingsListenerUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let syncV2SettingsListenerReturnValueLock = NSLock()
|
|
open var syncV2SettingsListenerUnderlyingReturnValue: TaskHandle!
|
|
open var syncV2SettingsListenerReturnValue: TaskHandle! {
|
|
get { syncV2SettingsListenerReturnValueLock.withLock { syncV2SettingsListenerUnderlyingReturnValue } }
|
|
set { syncV2SettingsListenerReturnValueLock.withLock { syncV2SettingsListenerUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var syncV2SettingsListenerClosure: ((SyncSettingsV2, SyncListenerV2) -> TaskHandle)?
|
|
|
|
open override func syncV2(settings: SyncSettingsV2, listener: SyncListenerV2) -> TaskHandle {
|
|
syncV2SettingsListenerCallsCountLock.withLock { syncV2SettingsListenerUnderlyingCallsCount += 1 }
|
|
syncV2SettingsListenerReceivedArguments = (settings: settings, listener: listener)
|
|
syncV2SettingsListenerReceivedInvocationsLock.withLock { syncV2SettingsListenerUnderlyingReceivedInvocations.append((settings: settings, listener: listener)) }
|
|
if let syncV2SettingsListenerClosure = syncV2SettingsListenerClosure {
|
|
return syncV2SettingsListenerClosure(settings, listener)
|
|
} else {
|
|
return syncV2SettingsListenerReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - tileServer
|
|
|
|
private let tileServerCallsCountLock = NSLock()
|
|
private var tileServerUnderlyingCallsCount = 0
|
|
open var tileServerCallsCount: Int {
|
|
get { tileServerCallsCountLock.withLock { tileServerUnderlyingCallsCount } }
|
|
set { tileServerCallsCountLock.withLock { tileServerUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var tileServerCalled: Bool {
|
|
return tileServerCallsCount > 0
|
|
}
|
|
|
|
private let tileServerReturnValueLock = NSLock()
|
|
open var tileServerUnderlyingReturnValue: TileServerInfo?
|
|
open var tileServerReturnValue: TileServerInfo? {
|
|
get { tileServerReturnValueLock.withLock { tileServerUnderlyingReturnValue } }
|
|
set { tileServerReturnValueLock.withLock { tileServerUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var tileServerClosure: (() async -> TileServerInfo?)?
|
|
|
|
open override func tileServer() async -> TileServerInfo? {
|
|
tileServerCallsCountLock.withLock { tileServerUnderlyingCallsCount += 1 }
|
|
if let tileServerClosure = tileServerClosure {
|
|
return await tileServerClosure()
|
|
} else {
|
|
return tileServerReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - trackRecentlyVisitedRoom
|
|
|
|
open var trackRecentlyVisitedRoomRoomThrowableError: Error?
|
|
private let trackRecentlyVisitedRoomRoomCallsCountLock = NSLock()
|
|
private var trackRecentlyVisitedRoomRoomUnderlyingCallsCount = 0
|
|
open var trackRecentlyVisitedRoomRoomCallsCount: Int {
|
|
get { trackRecentlyVisitedRoomRoomCallsCountLock.withLock { trackRecentlyVisitedRoomRoomUnderlyingCallsCount } }
|
|
set { trackRecentlyVisitedRoomRoomCallsCountLock.withLock { trackRecentlyVisitedRoomRoomUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var trackRecentlyVisitedRoomRoomCalled: Bool {
|
|
return trackRecentlyVisitedRoomRoomCallsCount > 0
|
|
}
|
|
private let trackRecentlyVisitedRoomRoomReceivedRoomLock = NSLock()
|
|
private var trackRecentlyVisitedRoomRoomUnderlyingReceivedRoom: String?
|
|
open var trackRecentlyVisitedRoomRoomReceivedRoom: String? {
|
|
get { trackRecentlyVisitedRoomRoomReceivedRoomLock.withLock { trackRecentlyVisitedRoomRoomUnderlyingReceivedRoom } }
|
|
set { trackRecentlyVisitedRoomRoomReceivedRoomLock.withLock { trackRecentlyVisitedRoomRoomUnderlyingReceivedRoom = newValue } }
|
|
}
|
|
private let trackRecentlyVisitedRoomRoomReceivedInvocationsLock = NSLock()
|
|
private var trackRecentlyVisitedRoomRoomUnderlyingReceivedInvocations: [String] = []
|
|
open var trackRecentlyVisitedRoomRoomReceivedInvocations: [String] {
|
|
get { trackRecentlyVisitedRoomRoomReceivedInvocationsLock.withLock { trackRecentlyVisitedRoomRoomUnderlyingReceivedInvocations } }
|
|
set { trackRecentlyVisitedRoomRoomReceivedInvocationsLock.withLock { trackRecentlyVisitedRoomRoomUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var trackRecentlyVisitedRoomRoomClosure: ((String) async throws -> Void)?
|
|
|
|
open override func trackRecentlyVisitedRoom(room: String) async throws {
|
|
if let error = trackRecentlyVisitedRoomRoomThrowableError {
|
|
throw error
|
|
}
|
|
trackRecentlyVisitedRoomRoomCallsCountLock.withLock { trackRecentlyVisitedRoomRoomUnderlyingCallsCount += 1 }
|
|
trackRecentlyVisitedRoomRoomReceivedRoom = room
|
|
trackRecentlyVisitedRoomRoomReceivedInvocationsLock.withLock { trackRecentlyVisitedRoomRoomUnderlyingReceivedInvocations.append(room) }
|
|
try await trackRecentlyVisitedRoomRoomClosure?(room)
|
|
}
|
|
|
|
//MARK: - unignoreUser
|
|
|
|
open var unignoreUserUserIdThrowableError: Error?
|
|
private let unignoreUserUserIdCallsCountLock = NSLock()
|
|
private var unignoreUserUserIdUnderlyingCallsCount = 0
|
|
open var unignoreUserUserIdCallsCount: Int {
|
|
get { unignoreUserUserIdCallsCountLock.withLock { unignoreUserUserIdUnderlyingCallsCount } }
|
|
set { unignoreUserUserIdCallsCountLock.withLock { unignoreUserUserIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var unignoreUserUserIdCalled: Bool {
|
|
return unignoreUserUserIdCallsCount > 0
|
|
}
|
|
private let unignoreUserUserIdReceivedUserIdLock = NSLock()
|
|
private var unignoreUserUserIdUnderlyingReceivedUserId: String?
|
|
open var unignoreUserUserIdReceivedUserId: String? {
|
|
get { unignoreUserUserIdReceivedUserIdLock.withLock { unignoreUserUserIdUnderlyingReceivedUserId } }
|
|
set { unignoreUserUserIdReceivedUserIdLock.withLock { unignoreUserUserIdUnderlyingReceivedUserId = newValue } }
|
|
}
|
|
private let unignoreUserUserIdReceivedInvocationsLock = NSLock()
|
|
private var unignoreUserUserIdUnderlyingReceivedInvocations: [String] = []
|
|
open var unignoreUserUserIdReceivedInvocations: [String] {
|
|
get { unignoreUserUserIdReceivedInvocationsLock.withLock { unignoreUserUserIdUnderlyingReceivedInvocations } }
|
|
set { unignoreUserUserIdReceivedInvocationsLock.withLock { unignoreUserUserIdUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var unignoreUserUserIdClosure: ((String) async throws -> Void)?
|
|
|
|
open override func unignoreUser(userId: String) async throws {
|
|
if let error = unignoreUserUserIdThrowableError {
|
|
throw error
|
|
}
|
|
unignoreUserUserIdCallsCountLock.withLock { unignoreUserUserIdUnderlyingCallsCount += 1 }
|
|
unignoreUserUserIdReceivedUserId = userId
|
|
unignoreUserUserIdReceivedInvocationsLock.withLock { unignoreUserUserIdUnderlyingReceivedInvocations.append(userId) }
|
|
try await unignoreUserUserIdClosure?(userId)
|
|
}
|
|
|
|
//MARK: - uploadAvatar
|
|
|
|
open var uploadAvatarMimeTypeDataThrowableError: Error?
|
|
private let uploadAvatarMimeTypeDataCallsCountLock = NSLock()
|
|
private var uploadAvatarMimeTypeDataUnderlyingCallsCount = 0
|
|
open var uploadAvatarMimeTypeDataCallsCount: Int {
|
|
get { uploadAvatarMimeTypeDataCallsCountLock.withLock { uploadAvatarMimeTypeDataUnderlyingCallsCount } }
|
|
set { uploadAvatarMimeTypeDataCallsCountLock.withLock { uploadAvatarMimeTypeDataUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var uploadAvatarMimeTypeDataCalled: Bool {
|
|
return uploadAvatarMimeTypeDataCallsCount > 0
|
|
}
|
|
private let uploadAvatarMimeTypeDataReceivedArgumentsLock = NSLock()
|
|
private var uploadAvatarMimeTypeDataUnderlyingReceivedArguments: (mimeType: String, data: Data)?
|
|
open var uploadAvatarMimeTypeDataReceivedArguments: (mimeType: String, data: Data)? {
|
|
get { uploadAvatarMimeTypeDataReceivedArgumentsLock.withLock { uploadAvatarMimeTypeDataUnderlyingReceivedArguments } }
|
|
set { uploadAvatarMimeTypeDataReceivedArgumentsLock.withLock { uploadAvatarMimeTypeDataUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let uploadAvatarMimeTypeDataReceivedInvocationsLock = NSLock()
|
|
private var uploadAvatarMimeTypeDataUnderlyingReceivedInvocations: [(mimeType: String, data: Data)] = []
|
|
open var uploadAvatarMimeTypeDataReceivedInvocations: [(mimeType: String, data: Data)] {
|
|
get { uploadAvatarMimeTypeDataReceivedInvocationsLock.withLock { uploadAvatarMimeTypeDataUnderlyingReceivedInvocations } }
|
|
set { uploadAvatarMimeTypeDataReceivedInvocationsLock.withLock { uploadAvatarMimeTypeDataUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var uploadAvatarMimeTypeDataClosure: ((String, Data) async throws -> Void)?
|
|
|
|
open override func uploadAvatar(mimeType: String, data: Data) async throws {
|
|
if let error = uploadAvatarMimeTypeDataThrowableError {
|
|
throw error
|
|
}
|
|
uploadAvatarMimeTypeDataCallsCountLock.withLock { uploadAvatarMimeTypeDataUnderlyingCallsCount += 1 }
|
|
uploadAvatarMimeTypeDataReceivedArguments = (mimeType: mimeType, data: data)
|
|
uploadAvatarMimeTypeDataReceivedInvocationsLock.withLock { uploadAvatarMimeTypeDataUnderlyingReceivedInvocations.append((mimeType: mimeType, data: data)) }
|
|
try await uploadAvatarMimeTypeDataClosure?(mimeType, data)
|
|
}
|
|
|
|
//MARK: - uploadMedia
|
|
|
|
open var uploadMediaMimeTypeDataProgressWatcherThrowableError: Error?
|
|
private let uploadMediaMimeTypeDataProgressWatcherCallsCountLock = NSLock()
|
|
private var uploadMediaMimeTypeDataProgressWatcherUnderlyingCallsCount = 0
|
|
open var uploadMediaMimeTypeDataProgressWatcherCallsCount: Int {
|
|
get { uploadMediaMimeTypeDataProgressWatcherCallsCountLock.withLock { uploadMediaMimeTypeDataProgressWatcherUnderlyingCallsCount } }
|
|
set { uploadMediaMimeTypeDataProgressWatcherCallsCountLock.withLock { uploadMediaMimeTypeDataProgressWatcherUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var uploadMediaMimeTypeDataProgressWatcherCalled: Bool {
|
|
return uploadMediaMimeTypeDataProgressWatcherCallsCount > 0
|
|
}
|
|
private let uploadMediaMimeTypeDataProgressWatcherReceivedArgumentsLock = NSLock()
|
|
private var uploadMediaMimeTypeDataProgressWatcherUnderlyingReceivedArguments: (mimeType: String, data: Data, progressWatcher: ProgressWatcher?)?
|
|
open var uploadMediaMimeTypeDataProgressWatcherReceivedArguments: (mimeType: String, data: Data, progressWatcher: ProgressWatcher?)? {
|
|
get { uploadMediaMimeTypeDataProgressWatcherReceivedArgumentsLock.withLock { uploadMediaMimeTypeDataProgressWatcherUnderlyingReceivedArguments } }
|
|
set { uploadMediaMimeTypeDataProgressWatcherReceivedArgumentsLock.withLock { uploadMediaMimeTypeDataProgressWatcherUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let uploadMediaMimeTypeDataProgressWatcherReceivedInvocationsLock = NSLock()
|
|
private var uploadMediaMimeTypeDataProgressWatcherUnderlyingReceivedInvocations: [(mimeType: String, data: Data, progressWatcher: ProgressWatcher?)] = []
|
|
open var uploadMediaMimeTypeDataProgressWatcherReceivedInvocations: [(mimeType: String, data: Data, progressWatcher: ProgressWatcher?)] {
|
|
get { uploadMediaMimeTypeDataProgressWatcherReceivedInvocationsLock.withLock { uploadMediaMimeTypeDataProgressWatcherUnderlyingReceivedInvocations } }
|
|
set { uploadMediaMimeTypeDataProgressWatcherReceivedInvocationsLock.withLock { uploadMediaMimeTypeDataProgressWatcherUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let uploadMediaMimeTypeDataProgressWatcherReturnValueLock = NSLock()
|
|
open var uploadMediaMimeTypeDataProgressWatcherUnderlyingReturnValue: String!
|
|
open var uploadMediaMimeTypeDataProgressWatcherReturnValue: String! {
|
|
get { uploadMediaMimeTypeDataProgressWatcherReturnValueLock.withLock { uploadMediaMimeTypeDataProgressWatcherUnderlyingReturnValue } }
|
|
set { uploadMediaMimeTypeDataProgressWatcherReturnValueLock.withLock { uploadMediaMimeTypeDataProgressWatcherUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var uploadMediaMimeTypeDataProgressWatcherClosure: ((String, Data, ProgressWatcher?) async throws -> String)?
|
|
|
|
open override func uploadMedia(mimeType: String, data: Data, progressWatcher: ProgressWatcher?) async throws -> String {
|
|
if let error = uploadMediaMimeTypeDataProgressWatcherThrowableError {
|
|
throw error
|
|
}
|
|
uploadMediaMimeTypeDataProgressWatcherCallsCountLock.withLock { uploadMediaMimeTypeDataProgressWatcherUnderlyingCallsCount += 1 }
|
|
uploadMediaMimeTypeDataProgressWatcherReceivedArguments = (mimeType: mimeType, data: data, progressWatcher: progressWatcher)
|
|
uploadMediaMimeTypeDataProgressWatcherReceivedInvocationsLock.withLock { uploadMediaMimeTypeDataProgressWatcherUnderlyingReceivedInvocations.append((mimeType: mimeType, data: data, progressWatcher: progressWatcher)) }
|
|
if let uploadMediaMimeTypeDataProgressWatcherClosure = uploadMediaMimeTypeDataProgressWatcherClosure {
|
|
return try await uploadMediaMimeTypeDataProgressWatcherClosure(mimeType, data, progressWatcher)
|
|
} else {
|
|
return uploadMediaMimeTypeDataProgressWatcherReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - urlForOauth
|
|
|
|
open var urlForOauthOauthConfigurationPromptLoginHintDeviceIdAdditionalScopesThrowableError: Error?
|
|
private let urlForOauthOauthConfigurationPromptLoginHintDeviceIdAdditionalScopesCallsCountLock = NSLock()
|
|
private var urlForOauthOauthConfigurationPromptLoginHintDeviceIdAdditionalScopesUnderlyingCallsCount = 0
|
|
open var urlForOauthOauthConfigurationPromptLoginHintDeviceIdAdditionalScopesCallsCount: Int {
|
|
get { urlForOauthOauthConfigurationPromptLoginHintDeviceIdAdditionalScopesCallsCountLock.withLock { urlForOauthOauthConfigurationPromptLoginHintDeviceIdAdditionalScopesUnderlyingCallsCount } }
|
|
set { urlForOauthOauthConfigurationPromptLoginHintDeviceIdAdditionalScopesCallsCountLock.withLock { urlForOauthOauthConfigurationPromptLoginHintDeviceIdAdditionalScopesUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var urlForOauthOauthConfigurationPromptLoginHintDeviceIdAdditionalScopesCalled: Bool {
|
|
return urlForOauthOauthConfigurationPromptLoginHintDeviceIdAdditionalScopesCallsCount > 0
|
|
}
|
|
private let urlForOauthOauthConfigurationPromptLoginHintDeviceIdAdditionalScopesReceivedArgumentsLock = NSLock()
|
|
private var urlForOauthOauthConfigurationPromptLoginHintDeviceIdAdditionalScopesUnderlyingReceivedArguments: (oauthConfiguration: OAuthConfiguration, prompt: OAuthPrompt?, loginHint: String?, deviceId: String?, additionalScopes: [String]?)?
|
|
open var urlForOauthOauthConfigurationPromptLoginHintDeviceIdAdditionalScopesReceivedArguments: (oauthConfiguration: OAuthConfiguration, prompt: OAuthPrompt?, loginHint: String?, deviceId: String?, additionalScopes: [String]?)? {
|
|
get { urlForOauthOauthConfigurationPromptLoginHintDeviceIdAdditionalScopesReceivedArgumentsLock.withLock { urlForOauthOauthConfigurationPromptLoginHintDeviceIdAdditionalScopesUnderlyingReceivedArguments } }
|
|
set { urlForOauthOauthConfigurationPromptLoginHintDeviceIdAdditionalScopesReceivedArgumentsLock.withLock { urlForOauthOauthConfigurationPromptLoginHintDeviceIdAdditionalScopesUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let urlForOauthOauthConfigurationPromptLoginHintDeviceIdAdditionalScopesReceivedInvocationsLock = NSLock()
|
|
private var urlForOauthOauthConfigurationPromptLoginHintDeviceIdAdditionalScopesUnderlyingReceivedInvocations: [(oauthConfiguration: OAuthConfiguration, prompt: OAuthPrompt?, loginHint: String?, deviceId: String?, additionalScopes: [String]?)] = []
|
|
open var urlForOauthOauthConfigurationPromptLoginHintDeviceIdAdditionalScopesReceivedInvocations: [(oauthConfiguration: OAuthConfiguration, prompt: OAuthPrompt?, loginHint: String?, deviceId: String?, additionalScopes: [String]?)] {
|
|
get { urlForOauthOauthConfigurationPromptLoginHintDeviceIdAdditionalScopesReceivedInvocationsLock.withLock { urlForOauthOauthConfigurationPromptLoginHintDeviceIdAdditionalScopesUnderlyingReceivedInvocations } }
|
|
set { urlForOauthOauthConfigurationPromptLoginHintDeviceIdAdditionalScopesReceivedInvocationsLock.withLock { urlForOauthOauthConfigurationPromptLoginHintDeviceIdAdditionalScopesUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let urlForOauthOauthConfigurationPromptLoginHintDeviceIdAdditionalScopesReturnValueLock = NSLock()
|
|
open var urlForOauthOauthConfigurationPromptLoginHintDeviceIdAdditionalScopesUnderlyingReturnValue: OAuthAuthorizationData!
|
|
open var urlForOauthOauthConfigurationPromptLoginHintDeviceIdAdditionalScopesReturnValue: OAuthAuthorizationData! {
|
|
get { urlForOauthOauthConfigurationPromptLoginHintDeviceIdAdditionalScopesReturnValueLock.withLock { urlForOauthOauthConfigurationPromptLoginHintDeviceIdAdditionalScopesUnderlyingReturnValue } }
|
|
set { urlForOauthOauthConfigurationPromptLoginHintDeviceIdAdditionalScopesReturnValueLock.withLock { urlForOauthOauthConfigurationPromptLoginHintDeviceIdAdditionalScopesUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var urlForOauthOauthConfigurationPromptLoginHintDeviceIdAdditionalScopesClosure: ((OAuthConfiguration, OAuthPrompt?, String?, String?, [String]?) async throws -> OAuthAuthorizationData)?
|
|
|
|
open override func urlForOauth(oauthConfiguration: OAuthConfiguration, prompt: OAuthPrompt?, loginHint: String?, deviceId: String?, additionalScopes: [String]?) async throws -> OAuthAuthorizationData {
|
|
if let error = urlForOauthOauthConfigurationPromptLoginHintDeviceIdAdditionalScopesThrowableError {
|
|
throw error
|
|
}
|
|
urlForOauthOauthConfigurationPromptLoginHintDeviceIdAdditionalScopesCallsCountLock.withLock { urlForOauthOauthConfigurationPromptLoginHintDeviceIdAdditionalScopesUnderlyingCallsCount += 1 }
|
|
urlForOauthOauthConfigurationPromptLoginHintDeviceIdAdditionalScopesReceivedArguments = (oauthConfiguration: oauthConfiguration, prompt: prompt, loginHint: loginHint, deviceId: deviceId, additionalScopes: additionalScopes)
|
|
urlForOauthOauthConfigurationPromptLoginHintDeviceIdAdditionalScopesReceivedInvocationsLock.withLock { urlForOauthOauthConfigurationPromptLoginHintDeviceIdAdditionalScopesUnderlyingReceivedInvocations.append((oauthConfiguration: oauthConfiguration, prompt: prompt, loginHint: loginHint, deviceId: deviceId, additionalScopes: additionalScopes)) }
|
|
if let urlForOauthOauthConfigurationPromptLoginHintDeviceIdAdditionalScopesClosure = urlForOauthOauthConfigurationPromptLoginHintDeviceIdAdditionalScopesClosure {
|
|
return try await urlForOauthOauthConfigurationPromptLoginHintDeviceIdAdditionalScopesClosure(oauthConfiguration, prompt, loginHint, deviceId, additionalScopes)
|
|
} else {
|
|
return urlForOauthOauthConfigurationPromptLoginHintDeviceIdAdditionalScopesReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - userId
|
|
|
|
open var userIdThrowableError: Error?
|
|
private let userIdCallsCountLock = NSLock()
|
|
private var userIdUnderlyingCallsCount = 0
|
|
open var userIdCallsCount: Int {
|
|
get { userIdCallsCountLock.withLock { userIdUnderlyingCallsCount } }
|
|
set { userIdCallsCountLock.withLock { userIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var userIdCalled: Bool {
|
|
return userIdCallsCount > 0
|
|
}
|
|
|
|
private let userIdReturnValueLock = NSLock()
|
|
open var userIdUnderlyingReturnValue: String!
|
|
open var userIdReturnValue: String! {
|
|
get { userIdReturnValueLock.withLock { userIdUnderlyingReturnValue } }
|
|
set { userIdReturnValueLock.withLock { userIdUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var userIdClosure: (() throws -> String)?
|
|
|
|
open override func userId() throws -> String {
|
|
if let error = userIdThrowableError {
|
|
throw error
|
|
}
|
|
userIdCallsCountLock.withLock { userIdUnderlyingCallsCount += 1 }
|
|
if let userIdClosure = userIdClosure {
|
|
return try userIdClosure()
|
|
} else {
|
|
return userIdReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - userIdServerName
|
|
|
|
open var userIdServerNameThrowableError: Error?
|
|
private let userIdServerNameCallsCountLock = NSLock()
|
|
private var userIdServerNameUnderlyingCallsCount = 0
|
|
open var userIdServerNameCallsCount: Int {
|
|
get { userIdServerNameCallsCountLock.withLock { userIdServerNameUnderlyingCallsCount } }
|
|
set { userIdServerNameCallsCountLock.withLock { userIdServerNameUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var userIdServerNameCalled: Bool {
|
|
return userIdServerNameCallsCount > 0
|
|
}
|
|
|
|
private let userIdServerNameReturnValueLock = NSLock()
|
|
open var userIdServerNameUnderlyingReturnValue: String!
|
|
open var userIdServerNameReturnValue: String! {
|
|
get { userIdServerNameReturnValueLock.withLock { userIdServerNameUnderlyingReturnValue } }
|
|
set { userIdServerNameReturnValueLock.withLock { userIdServerNameUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var userIdServerNameClosure: (() throws -> String)?
|
|
|
|
open override func userIdServerName() throws -> String {
|
|
if let error = userIdServerNameThrowableError {
|
|
throw error
|
|
}
|
|
userIdServerNameCallsCountLock.withLock { userIdServerNameUnderlyingCallsCount += 1 }
|
|
if let userIdServerNameClosure = userIdServerNameClosure {
|
|
return try userIdServerNameClosure()
|
|
} else {
|
|
return userIdServerNameReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - addRecentEmoji
|
|
|
|
open var addRecentEmojiEmojiThrowableError: Error?
|
|
private let addRecentEmojiEmojiCallsCountLock = NSLock()
|
|
private var addRecentEmojiEmojiUnderlyingCallsCount = 0
|
|
open var addRecentEmojiEmojiCallsCount: Int {
|
|
get { addRecentEmojiEmojiCallsCountLock.withLock { addRecentEmojiEmojiUnderlyingCallsCount } }
|
|
set { addRecentEmojiEmojiCallsCountLock.withLock { addRecentEmojiEmojiUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var addRecentEmojiEmojiCalled: Bool {
|
|
return addRecentEmojiEmojiCallsCount > 0
|
|
}
|
|
private let addRecentEmojiEmojiReceivedEmojiLock = NSLock()
|
|
private var addRecentEmojiEmojiUnderlyingReceivedEmoji: String?
|
|
open var addRecentEmojiEmojiReceivedEmoji: String? {
|
|
get { addRecentEmojiEmojiReceivedEmojiLock.withLock { addRecentEmojiEmojiUnderlyingReceivedEmoji } }
|
|
set { addRecentEmojiEmojiReceivedEmojiLock.withLock { addRecentEmojiEmojiUnderlyingReceivedEmoji = newValue } }
|
|
}
|
|
private let addRecentEmojiEmojiReceivedInvocationsLock = NSLock()
|
|
private var addRecentEmojiEmojiUnderlyingReceivedInvocations: [String] = []
|
|
open var addRecentEmojiEmojiReceivedInvocations: [String] {
|
|
get { addRecentEmojiEmojiReceivedInvocationsLock.withLock { addRecentEmojiEmojiUnderlyingReceivedInvocations } }
|
|
set { addRecentEmojiEmojiReceivedInvocationsLock.withLock { addRecentEmojiEmojiUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var addRecentEmojiEmojiClosure: ((String) async throws -> Void)?
|
|
|
|
open override func addRecentEmoji(emoji: String) async throws {
|
|
if let error = addRecentEmojiEmojiThrowableError {
|
|
throw error
|
|
}
|
|
addRecentEmojiEmojiCallsCountLock.withLock { addRecentEmojiEmojiUnderlyingCallsCount += 1 }
|
|
addRecentEmojiEmojiReceivedEmoji = emoji
|
|
addRecentEmojiEmojiReceivedInvocationsLock.withLock { addRecentEmojiEmojiUnderlyingReceivedInvocations.append(emoji) }
|
|
try await addRecentEmojiEmojiClosure?(emoji)
|
|
}
|
|
|
|
//MARK: - getRecentEmojis
|
|
|
|
open var getRecentEmojisThrowableError: Error?
|
|
private let getRecentEmojisCallsCountLock = NSLock()
|
|
private var getRecentEmojisUnderlyingCallsCount = 0
|
|
open var getRecentEmojisCallsCount: Int {
|
|
get { getRecentEmojisCallsCountLock.withLock { getRecentEmojisUnderlyingCallsCount } }
|
|
set { getRecentEmojisCallsCountLock.withLock { getRecentEmojisUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var getRecentEmojisCalled: Bool {
|
|
return getRecentEmojisCallsCount > 0
|
|
}
|
|
|
|
private let getRecentEmojisReturnValueLock = NSLock()
|
|
open var getRecentEmojisUnderlyingReturnValue: [RecentEmoji]!
|
|
open var getRecentEmojisReturnValue: [RecentEmoji]! {
|
|
get { getRecentEmojisReturnValueLock.withLock { getRecentEmojisUnderlyingReturnValue } }
|
|
set { getRecentEmojisReturnValueLock.withLock { getRecentEmojisUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var getRecentEmojisClosure: (() async throws -> [RecentEmoji])?
|
|
|
|
open override func getRecentEmojis() async throws -> [RecentEmoji] {
|
|
if let error = getRecentEmojisThrowableError {
|
|
throw error
|
|
}
|
|
getRecentEmojisCallsCountLock.withLock { getRecentEmojisUnderlyingCallsCount += 1 }
|
|
if let getRecentEmojisClosure = getRecentEmojisClosure {
|
|
return try await getRecentEmojisClosure()
|
|
} else {
|
|
return getRecentEmojisReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - searchService
|
|
|
|
private let searchServiceCallsCountLock = NSLock()
|
|
private var searchServiceUnderlyingCallsCount = 0
|
|
open var searchServiceCallsCount: Int {
|
|
get { searchServiceCallsCountLock.withLock { searchServiceUnderlyingCallsCount } }
|
|
set { searchServiceCallsCountLock.withLock { searchServiceUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var searchServiceCalled: Bool {
|
|
return searchServiceCallsCount > 0
|
|
}
|
|
|
|
private let searchServiceReturnValueLock = NSLock()
|
|
open var searchServiceUnderlyingReturnValue: SearchService!
|
|
open var searchServiceReturnValue: SearchService! {
|
|
get { searchServiceReturnValueLock.withLock { searchServiceUnderlyingReturnValue } }
|
|
set { searchServiceReturnValueLock.withLock { searchServiceUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var searchServiceClosure: (() -> SearchService)?
|
|
|
|
open override func searchService() -> SearchService {
|
|
searchServiceCallsCountLock.withLock { searchServiceUnderlyingCallsCount += 1 }
|
|
if let searchServiceClosure = searchServiceClosure {
|
|
return searchServiceClosure()
|
|
} else {
|
|
return searchServiceReturnValue
|
|
}
|
|
}
|
|
}
|
|
open class ClientBuilderSDKMock: MatrixRustSDK.ClientBuilder, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
|
|
//MARK: - addRootCertificates
|
|
|
|
private let addRootCertificatesCertificatesCallsCountLock = NSLock()
|
|
private var addRootCertificatesCertificatesUnderlyingCallsCount = 0
|
|
open var addRootCertificatesCertificatesCallsCount: Int {
|
|
get { addRootCertificatesCertificatesCallsCountLock.withLock { addRootCertificatesCertificatesUnderlyingCallsCount } }
|
|
set { addRootCertificatesCertificatesCallsCountLock.withLock { addRootCertificatesCertificatesUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var addRootCertificatesCertificatesCalled: Bool {
|
|
return addRootCertificatesCertificatesCallsCount > 0
|
|
}
|
|
private let addRootCertificatesCertificatesReceivedCertificatesLock = NSLock()
|
|
private var addRootCertificatesCertificatesUnderlyingReceivedCertificates: [Data]?
|
|
open var addRootCertificatesCertificatesReceivedCertificates: [Data]? {
|
|
get { addRootCertificatesCertificatesReceivedCertificatesLock.withLock { addRootCertificatesCertificatesUnderlyingReceivedCertificates } }
|
|
set { addRootCertificatesCertificatesReceivedCertificatesLock.withLock { addRootCertificatesCertificatesUnderlyingReceivedCertificates = newValue } }
|
|
}
|
|
private let addRootCertificatesCertificatesReceivedInvocationsLock = NSLock()
|
|
private var addRootCertificatesCertificatesUnderlyingReceivedInvocations: [[Data]] = []
|
|
open var addRootCertificatesCertificatesReceivedInvocations: [[Data]] {
|
|
get { addRootCertificatesCertificatesReceivedInvocationsLock.withLock { addRootCertificatesCertificatesUnderlyingReceivedInvocations } }
|
|
set { addRootCertificatesCertificatesReceivedInvocationsLock.withLock { addRootCertificatesCertificatesUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let addRootCertificatesCertificatesReturnValueLock = NSLock()
|
|
open var addRootCertificatesCertificatesUnderlyingReturnValue: ClientBuilder!
|
|
open var addRootCertificatesCertificatesReturnValue: ClientBuilder! {
|
|
get { addRootCertificatesCertificatesReturnValueLock.withLock { addRootCertificatesCertificatesUnderlyingReturnValue } }
|
|
set { addRootCertificatesCertificatesReturnValueLock.withLock { addRootCertificatesCertificatesUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var addRootCertificatesCertificatesClosure: (([Data]) -> ClientBuilder)?
|
|
|
|
open override func addRootCertificates(certificates: [Data]) -> ClientBuilder {
|
|
addRootCertificatesCertificatesCallsCountLock.withLock { addRootCertificatesCertificatesUnderlyingCallsCount += 1 }
|
|
addRootCertificatesCertificatesReceivedCertificates = certificates
|
|
addRootCertificatesCertificatesReceivedInvocationsLock.withLock { addRootCertificatesCertificatesUnderlyingReceivedInvocations.append(certificates) }
|
|
if let addRootCertificatesCertificatesClosure = addRootCertificatesCertificatesClosure {
|
|
return addRootCertificatesCertificatesClosure(certificates)
|
|
} else {
|
|
return addRootCertificatesCertificatesReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - autoEnableBackups
|
|
|
|
private let autoEnableBackupsAutoEnableBackupsCallsCountLock = NSLock()
|
|
private var autoEnableBackupsAutoEnableBackupsUnderlyingCallsCount = 0
|
|
open var autoEnableBackupsAutoEnableBackupsCallsCount: Int {
|
|
get { autoEnableBackupsAutoEnableBackupsCallsCountLock.withLock { autoEnableBackupsAutoEnableBackupsUnderlyingCallsCount } }
|
|
set { autoEnableBackupsAutoEnableBackupsCallsCountLock.withLock { autoEnableBackupsAutoEnableBackupsUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var autoEnableBackupsAutoEnableBackupsCalled: Bool {
|
|
return autoEnableBackupsAutoEnableBackupsCallsCount > 0
|
|
}
|
|
private let autoEnableBackupsAutoEnableBackupsReceivedAutoEnableBackupsLock = NSLock()
|
|
private var autoEnableBackupsAutoEnableBackupsUnderlyingReceivedAutoEnableBackups: Bool?
|
|
open var autoEnableBackupsAutoEnableBackupsReceivedAutoEnableBackups: Bool? {
|
|
get { autoEnableBackupsAutoEnableBackupsReceivedAutoEnableBackupsLock.withLock { autoEnableBackupsAutoEnableBackupsUnderlyingReceivedAutoEnableBackups } }
|
|
set { autoEnableBackupsAutoEnableBackupsReceivedAutoEnableBackupsLock.withLock { autoEnableBackupsAutoEnableBackupsUnderlyingReceivedAutoEnableBackups = newValue } }
|
|
}
|
|
private let autoEnableBackupsAutoEnableBackupsReceivedInvocationsLock = NSLock()
|
|
private var autoEnableBackupsAutoEnableBackupsUnderlyingReceivedInvocations: [Bool] = []
|
|
open var autoEnableBackupsAutoEnableBackupsReceivedInvocations: [Bool] {
|
|
get { autoEnableBackupsAutoEnableBackupsReceivedInvocationsLock.withLock { autoEnableBackupsAutoEnableBackupsUnderlyingReceivedInvocations } }
|
|
set { autoEnableBackupsAutoEnableBackupsReceivedInvocationsLock.withLock { autoEnableBackupsAutoEnableBackupsUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let autoEnableBackupsAutoEnableBackupsReturnValueLock = NSLock()
|
|
open var autoEnableBackupsAutoEnableBackupsUnderlyingReturnValue: ClientBuilder!
|
|
open var autoEnableBackupsAutoEnableBackupsReturnValue: ClientBuilder! {
|
|
get { autoEnableBackupsAutoEnableBackupsReturnValueLock.withLock { autoEnableBackupsAutoEnableBackupsUnderlyingReturnValue } }
|
|
set { autoEnableBackupsAutoEnableBackupsReturnValueLock.withLock { autoEnableBackupsAutoEnableBackupsUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var autoEnableBackupsAutoEnableBackupsClosure: ((Bool) -> ClientBuilder)?
|
|
|
|
open override func autoEnableBackups(autoEnableBackups: Bool) -> ClientBuilder {
|
|
autoEnableBackupsAutoEnableBackupsCallsCountLock.withLock { autoEnableBackupsAutoEnableBackupsUnderlyingCallsCount += 1 }
|
|
autoEnableBackupsAutoEnableBackupsReceivedAutoEnableBackups = autoEnableBackups
|
|
autoEnableBackupsAutoEnableBackupsReceivedInvocationsLock.withLock { autoEnableBackupsAutoEnableBackupsUnderlyingReceivedInvocations.append(autoEnableBackups) }
|
|
if let autoEnableBackupsAutoEnableBackupsClosure = autoEnableBackupsAutoEnableBackupsClosure {
|
|
return autoEnableBackupsAutoEnableBackupsClosure(autoEnableBackups)
|
|
} else {
|
|
return autoEnableBackupsAutoEnableBackupsReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - autoEnableCrossSigning
|
|
|
|
private let autoEnableCrossSigningAutoEnableCrossSigningCallsCountLock = NSLock()
|
|
private var autoEnableCrossSigningAutoEnableCrossSigningUnderlyingCallsCount = 0
|
|
open var autoEnableCrossSigningAutoEnableCrossSigningCallsCount: Int {
|
|
get { autoEnableCrossSigningAutoEnableCrossSigningCallsCountLock.withLock { autoEnableCrossSigningAutoEnableCrossSigningUnderlyingCallsCount } }
|
|
set { autoEnableCrossSigningAutoEnableCrossSigningCallsCountLock.withLock { autoEnableCrossSigningAutoEnableCrossSigningUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var autoEnableCrossSigningAutoEnableCrossSigningCalled: Bool {
|
|
return autoEnableCrossSigningAutoEnableCrossSigningCallsCount > 0
|
|
}
|
|
private let autoEnableCrossSigningAutoEnableCrossSigningReceivedAutoEnableCrossSigningLock = NSLock()
|
|
private var autoEnableCrossSigningAutoEnableCrossSigningUnderlyingReceivedAutoEnableCrossSigning: Bool?
|
|
open var autoEnableCrossSigningAutoEnableCrossSigningReceivedAutoEnableCrossSigning: Bool? {
|
|
get { autoEnableCrossSigningAutoEnableCrossSigningReceivedAutoEnableCrossSigningLock.withLock { autoEnableCrossSigningAutoEnableCrossSigningUnderlyingReceivedAutoEnableCrossSigning } }
|
|
set { autoEnableCrossSigningAutoEnableCrossSigningReceivedAutoEnableCrossSigningLock.withLock { autoEnableCrossSigningAutoEnableCrossSigningUnderlyingReceivedAutoEnableCrossSigning = newValue } }
|
|
}
|
|
private let autoEnableCrossSigningAutoEnableCrossSigningReceivedInvocationsLock = NSLock()
|
|
private var autoEnableCrossSigningAutoEnableCrossSigningUnderlyingReceivedInvocations: [Bool] = []
|
|
open var autoEnableCrossSigningAutoEnableCrossSigningReceivedInvocations: [Bool] {
|
|
get { autoEnableCrossSigningAutoEnableCrossSigningReceivedInvocationsLock.withLock { autoEnableCrossSigningAutoEnableCrossSigningUnderlyingReceivedInvocations } }
|
|
set { autoEnableCrossSigningAutoEnableCrossSigningReceivedInvocationsLock.withLock { autoEnableCrossSigningAutoEnableCrossSigningUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let autoEnableCrossSigningAutoEnableCrossSigningReturnValueLock = NSLock()
|
|
open var autoEnableCrossSigningAutoEnableCrossSigningUnderlyingReturnValue: ClientBuilder!
|
|
open var autoEnableCrossSigningAutoEnableCrossSigningReturnValue: ClientBuilder! {
|
|
get { autoEnableCrossSigningAutoEnableCrossSigningReturnValueLock.withLock { autoEnableCrossSigningAutoEnableCrossSigningUnderlyingReturnValue } }
|
|
set { autoEnableCrossSigningAutoEnableCrossSigningReturnValueLock.withLock { autoEnableCrossSigningAutoEnableCrossSigningUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var autoEnableCrossSigningAutoEnableCrossSigningClosure: ((Bool) -> ClientBuilder)?
|
|
|
|
open override func autoEnableCrossSigning(autoEnableCrossSigning: Bool) -> ClientBuilder {
|
|
autoEnableCrossSigningAutoEnableCrossSigningCallsCountLock.withLock { autoEnableCrossSigningAutoEnableCrossSigningUnderlyingCallsCount += 1 }
|
|
autoEnableCrossSigningAutoEnableCrossSigningReceivedAutoEnableCrossSigning = autoEnableCrossSigning
|
|
autoEnableCrossSigningAutoEnableCrossSigningReceivedInvocationsLock.withLock { autoEnableCrossSigningAutoEnableCrossSigningUnderlyingReceivedInvocations.append(autoEnableCrossSigning) }
|
|
if let autoEnableCrossSigningAutoEnableCrossSigningClosure = autoEnableCrossSigningAutoEnableCrossSigningClosure {
|
|
return autoEnableCrossSigningAutoEnableCrossSigningClosure(autoEnableCrossSigning)
|
|
} else {
|
|
return autoEnableCrossSigningAutoEnableCrossSigningReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - backupDownloadStrategy
|
|
|
|
private let backupDownloadStrategyBackupDownloadStrategyCallsCountLock = NSLock()
|
|
private var backupDownloadStrategyBackupDownloadStrategyUnderlyingCallsCount = 0
|
|
open var backupDownloadStrategyBackupDownloadStrategyCallsCount: Int {
|
|
get { backupDownloadStrategyBackupDownloadStrategyCallsCountLock.withLock { backupDownloadStrategyBackupDownloadStrategyUnderlyingCallsCount } }
|
|
set { backupDownloadStrategyBackupDownloadStrategyCallsCountLock.withLock { backupDownloadStrategyBackupDownloadStrategyUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var backupDownloadStrategyBackupDownloadStrategyCalled: Bool {
|
|
return backupDownloadStrategyBackupDownloadStrategyCallsCount > 0
|
|
}
|
|
private let backupDownloadStrategyBackupDownloadStrategyReceivedBackupDownloadStrategyLock = NSLock()
|
|
private var backupDownloadStrategyBackupDownloadStrategyUnderlyingReceivedBackupDownloadStrategy: BackupDownloadStrategy?
|
|
open var backupDownloadStrategyBackupDownloadStrategyReceivedBackupDownloadStrategy: BackupDownloadStrategy? {
|
|
get { backupDownloadStrategyBackupDownloadStrategyReceivedBackupDownloadStrategyLock.withLock { backupDownloadStrategyBackupDownloadStrategyUnderlyingReceivedBackupDownloadStrategy } }
|
|
set { backupDownloadStrategyBackupDownloadStrategyReceivedBackupDownloadStrategyLock.withLock { backupDownloadStrategyBackupDownloadStrategyUnderlyingReceivedBackupDownloadStrategy = newValue } }
|
|
}
|
|
private let backupDownloadStrategyBackupDownloadStrategyReceivedInvocationsLock = NSLock()
|
|
private var backupDownloadStrategyBackupDownloadStrategyUnderlyingReceivedInvocations: [BackupDownloadStrategy] = []
|
|
open var backupDownloadStrategyBackupDownloadStrategyReceivedInvocations: [BackupDownloadStrategy] {
|
|
get { backupDownloadStrategyBackupDownloadStrategyReceivedInvocationsLock.withLock { backupDownloadStrategyBackupDownloadStrategyUnderlyingReceivedInvocations } }
|
|
set { backupDownloadStrategyBackupDownloadStrategyReceivedInvocationsLock.withLock { backupDownloadStrategyBackupDownloadStrategyUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let backupDownloadStrategyBackupDownloadStrategyReturnValueLock = NSLock()
|
|
open var backupDownloadStrategyBackupDownloadStrategyUnderlyingReturnValue: ClientBuilder!
|
|
open var backupDownloadStrategyBackupDownloadStrategyReturnValue: ClientBuilder! {
|
|
get { backupDownloadStrategyBackupDownloadStrategyReturnValueLock.withLock { backupDownloadStrategyBackupDownloadStrategyUnderlyingReturnValue } }
|
|
set { backupDownloadStrategyBackupDownloadStrategyReturnValueLock.withLock { backupDownloadStrategyBackupDownloadStrategyUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var backupDownloadStrategyBackupDownloadStrategyClosure: ((BackupDownloadStrategy) -> ClientBuilder)?
|
|
|
|
open override func backupDownloadStrategy(backupDownloadStrategy: BackupDownloadStrategy) -> ClientBuilder {
|
|
backupDownloadStrategyBackupDownloadStrategyCallsCountLock.withLock { backupDownloadStrategyBackupDownloadStrategyUnderlyingCallsCount += 1 }
|
|
backupDownloadStrategyBackupDownloadStrategyReceivedBackupDownloadStrategy = backupDownloadStrategy
|
|
backupDownloadStrategyBackupDownloadStrategyReceivedInvocationsLock.withLock { backupDownloadStrategyBackupDownloadStrategyUnderlyingReceivedInvocations.append(backupDownloadStrategy) }
|
|
if let backupDownloadStrategyBackupDownloadStrategyClosure = backupDownloadStrategyBackupDownloadStrategyClosure {
|
|
return backupDownloadStrategyBackupDownloadStrategyClosure(backupDownloadStrategy)
|
|
} else {
|
|
return backupDownloadStrategyBackupDownloadStrategyReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - build
|
|
|
|
open var buildThrowableError: Error?
|
|
private let buildCallsCountLock = NSLock()
|
|
private var buildUnderlyingCallsCount = 0
|
|
open var buildCallsCount: Int {
|
|
get { buildCallsCountLock.withLock { buildUnderlyingCallsCount } }
|
|
set { buildCallsCountLock.withLock { buildUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var buildCalled: Bool {
|
|
return buildCallsCount > 0
|
|
}
|
|
|
|
private let buildReturnValueLock = NSLock()
|
|
open var buildUnderlyingReturnValue: Client!
|
|
open var buildReturnValue: Client! {
|
|
get { buildReturnValueLock.withLock { buildUnderlyingReturnValue } }
|
|
set { buildReturnValueLock.withLock { buildUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var buildClosure: (() async throws -> Client)?
|
|
|
|
open override func build() async throws -> Client {
|
|
if let error = buildThrowableError {
|
|
throw error
|
|
}
|
|
buildCallsCountLock.withLock { buildUnderlyingCallsCount += 1 }
|
|
if let buildClosure = buildClosure {
|
|
return try await buildClosure()
|
|
} else {
|
|
return buildReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - crossProcessLockConfig
|
|
|
|
private let crossProcessLockConfigCrossProcessLockConfigCallsCountLock = NSLock()
|
|
private var crossProcessLockConfigCrossProcessLockConfigUnderlyingCallsCount = 0
|
|
open var crossProcessLockConfigCrossProcessLockConfigCallsCount: Int {
|
|
get { crossProcessLockConfigCrossProcessLockConfigCallsCountLock.withLock { crossProcessLockConfigCrossProcessLockConfigUnderlyingCallsCount } }
|
|
set { crossProcessLockConfigCrossProcessLockConfigCallsCountLock.withLock { crossProcessLockConfigCrossProcessLockConfigUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var crossProcessLockConfigCrossProcessLockConfigCalled: Bool {
|
|
return crossProcessLockConfigCrossProcessLockConfigCallsCount > 0
|
|
}
|
|
private let crossProcessLockConfigCrossProcessLockConfigReceivedCrossProcessLockConfigLock = NSLock()
|
|
private var crossProcessLockConfigCrossProcessLockConfigUnderlyingReceivedCrossProcessLockConfig: CrossProcessLockConfig?
|
|
open var crossProcessLockConfigCrossProcessLockConfigReceivedCrossProcessLockConfig: CrossProcessLockConfig? {
|
|
get { crossProcessLockConfigCrossProcessLockConfigReceivedCrossProcessLockConfigLock.withLock { crossProcessLockConfigCrossProcessLockConfigUnderlyingReceivedCrossProcessLockConfig } }
|
|
set { crossProcessLockConfigCrossProcessLockConfigReceivedCrossProcessLockConfigLock.withLock { crossProcessLockConfigCrossProcessLockConfigUnderlyingReceivedCrossProcessLockConfig = newValue } }
|
|
}
|
|
private let crossProcessLockConfigCrossProcessLockConfigReceivedInvocationsLock = NSLock()
|
|
private var crossProcessLockConfigCrossProcessLockConfigUnderlyingReceivedInvocations: [CrossProcessLockConfig] = []
|
|
open var crossProcessLockConfigCrossProcessLockConfigReceivedInvocations: [CrossProcessLockConfig] {
|
|
get { crossProcessLockConfigCrossProcessLockConfigReceivedInvocationsLock.withLock { crossProcessLockConfigCrossProcessLockConfigUnderlyingReceivedInvocations } }
|
|
set { crossProcessLockConfigCrossProcessLockConfigReceivedInvocationsLock.withLock { crossProcessLockConfigCrossProcessLockConfigUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let crossProcessLockConfigCrossProcessLockConfigReturnValueLock = NSLock()
|
|
open var crossProcessLockConfigCrossProcessLockConfigUnderlyingReturnValue: ClientBuilder!
|
|
open var crossProcessLockConfigCrossProcessLockConfigReturnValue: ClientBuilder! {
|
|
get { crossProcessLockConfigCrossProcessLockConfigReturnValueLock.withLock { crossProcessLockConfigCrossProcessLockConfigUnderlyingReturnValue } }
|
|
set { crossProcessLockConfigCrossProcessLockConfigReturnValueLock.withLock { crossProcessLockConfigCrossProcessLockConfigUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var crossProcessLockConfigCrossProcessLockConfigClosure: ((CrossProcessLockConfig) -> ClientBuilder)?
|
|
|
|
open override func crossProcessLockConfig(crossProcessLockConfig: CrossProcessLockConfig) -> ClientBuilder {
|
|
crossProcessLockConfigCrossProcessLockConfigCallsCountLock.withLock { crossProcessLockConfigCrossProcessLockConfigUnderlyingCallsCount += 1 }
|
|
crossProcessLockConfigCrossProcessLockConfigReceivedCrossProcessLockConfig = crossProcessLockConfig
|
|
crossProcessLockConfigCrossProcessLockConfigReceivedInvocationsLock.withLock { crossProcessLockConfigCrossProcessLockConfigUnderlyingReceivedInvocations.append(crossProcessLockConfig) }
|
|
if let crossProcessLockConfigCrossProcessLockConfigClosure = crossProcessLockConfigCrossProcessLockConfigClosure {
|
|
return crossProcessLockConfigCrossProcessLockConfigClosure(crossProcessLockConfig)
|
|
} else {
|
|
return crossProcessLockConfigCrossProcessLockConfigReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - decryptionSettings
|
|
|
|
private let decryptionSettingsDecryptionSettingsCallsCountLock = NSLock()
|
|
private var decryptionSettingsDecryptionSettingsUnderlyingCallsCount = 0
|
|
open var decryptionSettingsDecryptionSettingsCallsCount: Int {
|
|
get { decryptionSettingsDecryptionSettingsCallsCountLock.withLock { decryptionSettingsDecryptionSettingsUnderlyingCallsCount } }
|
|
set { decryptionSettingsDecryptionSettingsCallsCountLock.withLock { decryptionSettingsDecryptionSettingsUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var decryptionSettingsDecryptionSettingsCalled: Bool {
|
|
return decryptionSettingsDecryptionSettingsCallsCount > 0
|
|
}
|
|
private let decryptionSettingsDecryptionSettingsReceivedDecryptionSettingsLock = NSLock()
|
|
private var decryptionSettingsDecryptionSettingsUnderlyingReceivedDecryptionSettings: DecryptionSettings?
|
|
open var decryptionSettingsDecryptionSettingsReceivedDecryptionSettings: DecryptionSettings? {
|
|
get { decryptionSettingsDecryptionSettingsReceivedDecryptionSettingsLock.withLock { decryptionSettingsDecryptionSettingsUnderlyingReceivedDecryptionSettings } }
|
|
set { decryptionSettingsDecryptionSettingsReceivedDecryptionSettingsLock.withLock { decryptionSettingsDecryptionSettingsUnderlyingReceivedDecryptionSettings = newValue } }
|
|
}
|
|
private let decryptionSettingsDecryptionSettingsReceivedInvocationsLock = NSLock()
|
|
private var decryptionSettingsDecryptionSettingsUnderlyingReceivedInvocations: [DecryptionSettings] = []
|
|
open var decryptionSettingsDecryptionSettingsReceivedInvocations: [DecryptionSettings] {
|
|
get { decryptionSettingsDecryptionSettingsReceivedInvocationsLock.withLock { decryptionSettingsDecryptionSettingsUnderlyingReceivedInvocations } }
|
|
set { decryptionSettingsDecryptionSettingsReceivedInvocationsLock.withLock { decryptionSettingsDecryptionSettingsUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let decryptionSettingsDecryptionSettingsReturnValueLock = NSLock()
|
|
open var decryptionSettingsDecryptionSettingsUnderlyingReturnValue: ClientBuilder!
|
|
open var decryptionSettingsDecryptionSettingsReturnValue: ClientBuilder! {
|
|
get { decryptionSettingsDecryptionSettingsReturnValueLock.withLock { decryptionSettingsDecryptionSettingsUnderlyingReturnValue } }
|
|
set { decryptionSettingsDecryptionSettingsReturnValueLock.withLock { decryptionSettingsDecryptionSettingsUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var decryptionSettingsDecryptionSettingsClosure: ((DecryptionSettings) -> ClientBuilder)?
|
|
|
|
open override func decryptionSettings(decryptionSettings: DecryptionSettings) -> ClientBuilder {
|
|
decryptionSettingsDecryptionSettingsCallsCountLock.withLock { decryptionSettingsDecryptionSettingsUnderlyingCallsCount += 1 }
|
|
decryptionSettingsDecryptionSettingsReceivedDecryptionSettings = decryptionSettings
|
|
decryptionSettingsDecryptionSettingsReceivedInvocationsLock.withLock { decryptionSettingsDecryptionSettingsUnderlyingReceivedInvocations.append(decryptionSettings) }
|
|
if let decryptionSettingsDecryptionSettingsClosure = decryptionSettingsDecryptionSettingsClosure {
|
|
return decryptionSettingsDecryptionSettingsClosure(decryptionSettings)
|
|
} else {
|
|
return decryptionSettingsDecryptionSettingsReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - disableAutomaticTokenRefresh
|
|
|
|
private let disableAutomaticTokenRefreshCallsCountLock = NSLock()
|
|
private var disableAutomaticTokenRefreshUnderlyingCallsCount = 0
|
|
open var disableAutomaticTokenRefreshCallsCount: Int {
|
|
get { disableAutomaticTokenRefreshCallsCountLock.withLock { disableAutomaticTokenRefreshUnderlyingCallsCount } }
|
|
set { disableAutomaticTokenRefreshCallsCountLock.withLock { disableAutomaticTokenRefreshUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var disableAutomaticTokenRefreshCalled: Bool {
|
|
return disableAutomaticTokenRefreshCallsCount > 0
|
|
}
|
|
|
|
private let disableAutomaticTokenRefreshReturnValueLock = NSLock()
|
|
open var disableAutomaticTokenRefreshUnderlyingReturnValue: ClientBuilder!
|
|
open var disableAutomaticTokenRefreshReturnValue: ClientBuilder! {
|
|
get { disableAutomaticTokenRefreshReturnValueLock.withLock { disableAutomaticTokenRefreshUnderlyingReturnValue } }
|
|
set { disableAutomaticTokenRefreshReturnValueLock.withLock { disableAutomaticTokenRefreshUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var disableAutomaticTokenRefreshClosure: (() -> ClientBuilder)?
|
|
|
|
open override func disableAutomaticTokenRefresh() -> ClientBuilder {
|
|
disableAutomaticTokenRefreshCallsCountLock.withLock { disableAutomaticTokenRefreshUnderlyingCallsCount += 1 }
|
|
if let disableAutomaticTokenRefreshClosure = disableAutomaticTokenRefreshClosure {
|
|
return disableAutomaticTokenRefreshClosure()
|
|
} else {
|
|
return disableAutomaticTokenRefreshReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - disableBuiltInRootCertificates
|
|
|
|
private let disableBuiltInRootCertificatesCallsCountLock = NSLock()
|
|
private var disableBuiltInRootCertificatesUnderlyingCallsCount = 0
|
|
open var disableBuiltInRootCertificatesCallsCount: Int {
|
|
get { disableBuiltInRootCertificatesCallsCountLock.withLock { disableBuiltInRootCertificatesUnderlyingCallsCount } }
|
|
set { disableBuiltInRootCertificatesCallsCountLock.withLock { disableBuiltInRootCertificatesUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var disableBuiltInRootCertificatesCalled: Bool {
|
|
return disableBuiltInRootCertificatesCallsCount > 0
|
|
}
|
|
|
|
private let disableBuiltInRootCertificatesReturnValueLock = NSLock()
|
|
open var disableBuiltInRootCertificatesUnderlyingReturnValue: ClientBuilder!
|
|
open var disableBuiltInRootCertificatesReturnValue: ClientBuilder! {
|
|
get { disableBuiltInRootCertificatesReturnValueLock.withLock { disableBuiltInRootCertificatesUnderlyingReturnValue } }
|
|
set { disableBuiltInRootCertificatesReturnValueLock.withLock { disableBuiltInRootCertificatesUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var disableBuiltInRootCertificatesClosure: (() -> ClientBuilder)?
|
|
|
|
open override func disableBuiltInRootCertificates() -> ClientBuilder {
|
|
disableBuiltInRootCertificatesCallsCountLock.withLock { disableBuiltInRootCertificatesUnderlyingCallsCount += 1 }
|
|
if let disableBuiltInRootCertificatesClosure = disableBuiltInRootCertificatesClosure {
|
|
return disableBuiltInRootCertificatesClosure()
|
|
} else {
|
|
return disableBuiltInRootCertificatesReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - disableSslVerification
|
|
|
|
private let disableSslVerificationCallsCountLock = NSLock()
|
|
private var disableSslVerificationUnderlyingCallsCount = 0
|
|
open var disableSslVerificationCallsCount: Int {
|
|
get { disableSslVerificationCallsCountLock.withLock { disableSslVerificationUnderlyingCallsCount } }
|
|
set { disableSslVerificationCallsCountLock.withLock { disableSslVerificationUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var disableSslVerificationCalled: Bool {
|
|
return disableSslVerificationCallsCount > 0
|
|
}
|
|
|
|
private let disableSslVerificationReturnValueLock = NSLock()
|
|
open var disableSslVerificationUnderlyingReturnValue: ClientBuilder!
|
|
open var disableSslVerificationReturnValue: ClientBuilder! {
|
|
get { disableSslVerificationReturnValueLock.withLock { disableSslVerificationUnderlyingReturnValue } }
|
|
set { disableSslVerificationReturnValueLock.withLock { disableSslVerificationUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var disableSslVerificationClosure: (() -> ClientBuilder)?
|
|
|
|
open override func disableSslVerification() -> ClientBuilder {
|
|
disableSslVerificationCallsCountLock.withLock { disableSslVerificationUnderlyingCallsCount += 1 }
|
|
if let disableSslVerificationClosure = disableSslVerificationClosure {
|
|
return disableSslVerificationClosure()
|
|
} else {
|
|
return disableSslVerificationReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - dmRoomDefinition
|
|
|
|
private let dmRoomDefinitionDmRoomDefinitionCallsCountLock = NSLock()
|
|
private var dmRoomDefinitionDmRoomDefinitionUnderlyingCallsCount = 0
|
|
open var dmRoomDefinitionDmRoomDefinitionCallsCount: Int {
|
|
get { dmRoomDefinitionDmRoomDefinitionCallsCountLock.withLock { dmRoomDefinitionDmRoomDefinitionUnderlyingCallsCount } }
|
|
set { dmRoomDefinitionDmRoomDefinitionCallsCountLock.withLock { dmRoomDefinitionDmRoomDefinitionUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var dmRoomDefinitionDmRoomDefinitionCalled: Bool {
|
|
return dmRoomDefinitionDmRoomDefinitionCallsCount > 0
|
|
}
|
|
private let dmRoomDefinitionDmRoomDefinitionReceivedDmRoomDefinitionLock = NSLock()
|
|
private var dmRoomDefinitionDmRoomDefinitionUnderlyingReceivedDmRoomDefinition: DmRoomDefinition?
|
|
open var dmRoomDefinitionDmRoomDefinitionReceivedDmRoomDefinition: DmRoomDefinition? {
|
|
get { dmRoomDefinitionDmRoomDefinitionReceivedDmRoomDefinitionLock.withLock { dmRoomDefinitionDmRoomDefinitionUnderlyingReceivedDmRoomDefinition } }
|
|
set { dmRoomDefinitionDmRoomDefinitionReceivedDmRoomDefinitionLock.withLock { dmRoomDefinitionDmRoomDefinitionUnderlyingReceivedDmRoomDefinition = newValue } }
|
|
}
|
|
private let dmRoomDefinitionDmRoomDefinitionReceivedInvocationsLock = NSLock()
|
|
private var dmRoomDefinitionDmRoomDefinitionUnderlyingReceivedInvocations: [DmRoomDefinition] = []
|
|
open var dmRoomDefinitionDmRoomDefinitionReceivedInvocations: [DmRoomDefinition] {
|
|
get { dmRoomDefinitionDmRoomDefinitionReceivedInvocationsLock.withLock { dmRoomDefinitionDmRoomDefinitionUnderlyingReceivedInvocations } }
|
|
set { dmRoomDefinitionDmRoomDefinitionReceivedInvocationsLock.withLock { dmRoomDefinitionDmRoomDefinitionUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let dmRoomDefinitionDmRoomDefinitionReturnValueLock = NSLock()
|
|
open var dmRoomDefinitionDmRoomDefinitionUnderlyingReturnValue: ClientBuilder!
|
|
open var dmRoomDefinitionDmRoomDefinitionReturnValue: ClientBuilder! {
|
|
get { dmRoomDefinitionDmRoomDefinitionReturnValueLock.withLock { dmRoomDefinitionDmRoomDefinitionUnderlyingReturnValue } }
|
|
set { dmRoomDefinitionDmRoomDefinitionReturnValueLock.withLock { dmRoomDefinitionDmRoomDefinitionUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var dmRoomDefinitionDmRoomDefinitionClosure: ((DmRoomDefinition) -> ClientBuilder)?
|
|
|
|
open override func dmRoomDefinition(dmRoomDefinition: DmRoomDefinition) -> ClientBuilder {
|
|
dmRoomDefinitionDmRoomDefinitionCallsCountLock.withLock { dmRoomDefinitionDmRoomDefinitionUnderlyingCallsCount += 1 }
|
|
dmRoomDefinitionDmRoomDefinitionReceivedDmRoomDefinition = dmRoomDefinition
|
|
dmRoomDefinitionDmRoomDefinitionReceivedInvocationsLock.withLock { dmRoomDefinitionDmRoomDefinitionUnderlyingReceivedInvocations.append(dmRoomDefinition) }
|
|
if let dmRoomDefinitionDmRoomDefinitionClosure = dmRoomDefinitionDmRoomDefinitionClosure {
|
|
return dmRoomDefinitionDmRoomDefinitionClosure(dmRoomDefinition)
|
|
} else {
|
|
return dmRoomDefinitionDmRoomDefinitionReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - enableShareHistoryOnInvite
|
|
|
|
private let enableShareHistoryOnInviteEnableShareHistoryOnInviteCallsCountLock = NSLock()
|
|
private var enableShareHistoryOnInviteEnableShareHistoryOnInviteUnderlyingCallsCount = 0
|
|
open var enableShareHistoryOnInviteEnableShareHistoryOnInviteCallsCount: Int {
|
|
get { enableShareHistoryOnInviteEnableShareHistoryOnInviteCallsCountLock.withLock { enableShareHistoryOnInviteEnableShareHistoryOnInviteUnderlyingCallsCount } }
|
|
set { enableShareHistoryOnInviteEnableShareHistoryOnInviteCallsCountLock.withLock { enableShareHistoryOnInviteEnableShareHistoryOnInviteUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var enableShareHistoryOnInviteEnableShareHistoryOnInviteCalled: Bool {
|
|
return enableShareHistoryOnInviteEnableShareHistoryOnInviteCallsCount > 0
|
|
}
|
|
private let enableShareHistoryOnInviteEnableShareHistoryOnInviteReceivedEnableShareHistoryOnInviteLock = NSLock()
|
|
private var enableShareHistoryOnInviteEnableShareHistoryOnInviteUnderlyingReceivedEnableShareHistoryOnInvite: Bool?
|
|
open var enableShareHistoryOnInviteEnableShareHistoryOnInviteReceivedEnableShareHistoryOnInvite: Bool? {
|
|
get { enableShareHistoryOnInviteEnableShareHistoryOnInviteReceivedEnableShareHistoryOnInviteLock.withLock { enableShareHistoryOnInviteEnableShareHistoryOnInviteUnderlyingReceivedEnableShareHistoryOnInvite } }
|
|
set { enableShareHistoryOnInviteEnableShareHistoryOnInviteReceivedEnableShareHistoryOnInviteLock.withLock { enableShareHistoryOnInviteEnableShareHistoryOnInviteUnderlyingReceivedEnableShareHistoryOnInvite = newValue } }
|
|
}
|
|
private let enableShareHistoryOnInviteEnableShareHistoryOnInviteReceivedInvocationsLock = NSLock()
|
|
private var enableShareHistoryOnInviteEnableShareHistoryOnInviteUnderlyingReceivedInvocations: [Bool] = []
|
|
open var enableShareHistoryOnInviteEnableShareHistoryOnInviteReceivedInvocations: [Bool] {
|
|
get { enableShareHistoryOnInviteEnableShareHistoryOnInviteReceivedInvocationsLock.withLock { enableShareHistoryOnInviteEnableShareHistoryOnInviteUnderlyingReceivedInvocations } }
|
|
set { enableShareHistoryOnInviteEnableShareHistoryOnInviteReceivedInvocationsLock.withLock { enableShareHistoryOnInviteEnableShareHistoryOnInviteUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let enableShareHistoryOnInviteEnableShareHistoryOnInviteReturnValueLock = NSLock()
|
|
open var enableShareHistoryOnInviteEnableShareHistoryOnInviteUnderlyingReturnValue: ClientBuilder!
|
|
open var enableShareHistoryOnInviteEnableShareHistoryOnInviteReturnValue: ClientBuilder! {
|
|
get { enableShareHistoryOnInviteEnableShareHistoryOnInviteReturnValueLock.withLock { enableShareHistoryOnInviteEnableShareHistoryOnInviteUnderlyingReturnValue } }
|
|
set { enableShareHistoryOnInviteEnableShareHistoryOnInviteReturnValueLock.withLock { enableShareHistoryOnInviteEnableShareHistoryOnInviteUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var enableShareHistoryOnInviteEnableShareHistoryOnInviteClosure: ((Bool) -> ClientBuilder)?
|
|
|
|
open override func enableShareHistoryOnInvite(enableShareHistoryOnInvite: Bool) -> ClientBuilder {
|
|
enableShareHistoryOnInviteEnableShareHistoryOnInviteCallsCountLock.withLock { enableShareHistoryOnInviteEnableShareHistoryOnInviteUnderlyingCallsCount += 1 }
|
|
enableShareHistoryOnInviteEnableShareHistoryOnInviteReceivedEnableShareHistoryOnInvite = enableShareHistoryOnInvite
|
|
enableShareHistoryOnInviteEnableShareHistoryOnInviteReceivedInvocationsLock.withLock { enableShareHistoryOnInviteEnableShareHistoryOnInviteUnderlyingReceivedInvocations.append(enableShareHistoryOnInvite) }
|
|
if let enableShareHistoryOnInviteEnableShareHistoryOnInviteClosure = enableShareHistoryOnInviteEnableShareHistoryOnInviteClosure {
|
|
return enableShareHistoryOnInviteEnableShareHistoryOnInviteClosure(enableShareHistoryOnInvite)
|
|
} else {
|
|
return enableShareHistoryOnInviteEnableShareHistoryOnInviteReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - homeserverUrl
|
|
|
|
private let homeserverUrlUrlCallsCountLock = NSLock()
|
|
private var homeserverUrlUrlUnderlyingCallsCount = 0
|
|
open var homeserverUrlUrlCallsCount: Int {
|
|
get { homeserverUrlUrlCallsCountLock.withLock { homeserverUrlUrlUnderlyingCallsCount } }
|
|
set { homeserverUrlUrlCallsCountLock.withLock { homeserverUrlUrlUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var homeserverUrlUrlCalled: Bool {
|
|
return homeserverUrlUrlCallsCount > 0
|
|
}
|
|
private let homeserverUrlUrlReceivedUrlLock = NSLock()
|
|
private var homeserverUrlUrlUnderlyingReceivedUrl: String?
|
|
open var homeserverUrlUrlReceivedUrl: String? {
|
|
get { homeserverUrlUrlReceivedUrlLock.withLock { homeserverUrlUrlUnderlyingReceivedUrl } }
|
|
set { homeserverUrlUrlReceivedUrlLock.withLock { homeserverUrlUrlUnderlyingReceivedUrl = newValue } }
|
|
}
|
|
private let homeserverUrlUrlReceivedInvocationsLock = NSLock()
|
|
private var homeserverUrlUrlUnderlyingReceivedInvocations: [String] = []
|
|
open var homeserverUrlUrlReceivedInvocations: [String] {
|
|
get { homeserverUrlUrlReceivedInvocationsLock.withLock { homeserverUrlUrlUnderlyingReceivedInvocations } }
|
|
set { homeserverUrlUrlReceivedInvocationsLock.withLock { homeserverUrlUrlUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let homeserverUrlUrlReturnValueLock = NSLock()
|
|
open var homeserverUrlUrlUnderlyingReturnValue: ClientBuilder!
|
|
open var homeserverUrlUrlReturnValue: ClientBuilder! {
|
|
get { homeserverUrlUrlReturnValueLock.withLock { homeserverUrlUrlUnderlyingReturnValue } }
|
|
set { homeserverUrlUrlReturnValueLock.withLock { homeserverUrlUrlUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var homeserverUrlUrlClosure: ((String) -> ClientBuilder)?
|
|
|
|
open override func homeserverUrl(url: String) -> ClientBuilder {
|
|
homeserverUrlUrlCallsCountLock.withLock { homeserverUrlUrlUnderlyingCallsCount += 1 }
|
|
homeserverUrlUrlReceivedUrl = url
|
|
homeserverUrlUrlReceivedInvocationsLock.withLock { homeserverUrlUrlUnderlyingReceivedInvocations.append(url) }
|
|
if let homeserverUrlUrlClosure = homeserverUrlUrlClosure {
|
|
return homeserverUrlUrlClosure(url)
|
|
} else {
|
|
return homeserverUrlUrlReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - inMemoryStore
|
|
|
|
private let inMemoryStoreCallsCountLock = NSLock()
|
|
private var inMemoryStoreUnderlyingCallsCount = 0
|
|
open var inMemoryStoreCallsCount: Int {
|
|
get { inMemoryStoreCallsCountLock.withLock { inMemoryStoreUnderlyingCallsCount } }
|
|
set { inMemoryStoreCallsCountLock.withLock { inMemoryStoreUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var inMemoryStoreCalled: Bool {
|
|
return inMemoryStoreCallsCount > 0
|
|
}
|
|
|
|
private let inMemoryStoreReturnValueLock = NSLock()
|
|
open var inMemoryStoreUnderlyingReturnValue: ClientBuilder!
|
|
open var inMemoryStoreReturnValue: ClientBuilder! {
|
|
get { inMemoryStoreReturnValueLock.withLock { inMemoryStoreUnderlyingReturnValue } }
|
|
set { inMemoryStoreReturnValueLock.withLock { inMemoryStoreUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var inMemoryStoreClosure: (() -> ClientBuilder)?
|
|
|
|
open override func inMemoryStore() -> ClientBuilder {
|
|
inMemoryStoreCallsCountLock.withLock { inMemoryStoreUnderlyingCallsCount += 1 }
|
|
if let inMemoryStoreClosure = inMemoryStoreClosure {
|
|
return inMemoryStoreClosure()
|
|
} else {
|
|
return inMemoryStoreReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - proxy
|
|
|
|
private let proxyUrlCallsCountLock = NSLock()
|
|
private var proxyUrlUnderlyingCallsCount = 0
|
|
open var proxyUrlCallsCount: Int {
|
|
get { proxyUrlCallsCountLock.withLock { proxyUrlUnderlyingCallsCount } }
|
|
set { proxyUrlCallsCountLock.withLock { proxyUrlUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var proxyUrlCalled: Bool {
|
|
return proxyUrlCallsCount > 0
|
|
}
|
|
private let proxyUrlReceivedUrlLock = NSLock()
|
|
private var proxyUrlUnderlyingReceivedUrl: String?
|
|
open var proxyUrlReceivedUrl: String? {
|
|
get { proxyUrlReceivedUrlLock.withLock { proxyUrlUnderlyingReceivedUrl } }
|
|
set { proxyUrlReceivedUrlLock.withLock { proxyUrlUnderlyingReceivedUrl = newValue } }
|
|
}
|
|
private let proxyUrlReceivedInvocationsLock = NSLock()
|
|
private var proxyUrlUnderlyingReceivedInvocations: [String] = []
|
|
open var proxyUrlReceivedInvocations: [String] {
|
|
get { proxyUrlReceivedInvocationsLock.withLock { proxyUrlUnderlyingReceivedInvocations } }
|
|
set { proxyUrlReceivedInvocationsLock.withLock { proxyUrlUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let proxyUrlReturnValueLock = NSLock()
|
|
open var proxyUrlUnderlyingReturnValue: ClientBuilder!
|
|
open var proxyUrlReturnValue: ClientBuilder! {
|
|
get { proxyUrlReturnValueLock.withLock { proxyUrlUnderlyingReturnValue } }
|
|
set { proxyUrlReturnValueLock.withLock { proxyUrlUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var proxyUrlClosure: ((String) -> ClientBuilder)?
|
|
|
|
open override func proxy(url: String) -> ClientBuilder {
|
|
proxyUrlCallsCountLock.withLock { proxyUrlUnderlyingCallsCount += 1 }
|
|
proxyUrlReceivedUrl = url
|
|
proxyUrlReceivedInvocationsLock.withLock { proxyUrlUnderlyingReceivedInvocations.append(url) }
|
|
if let proxyUrlClosure = proxyUrlClosure {
|
|
return proxyUrlClosure(url)
|
|
} else {
|
|
return proxyUrlReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - requestConfig
|
|
|
|
private let requestConfigConfigCallsCountLock = NSLock()
|
|
private var requestConfigConfigUnderlyingCallsCount = 0
|
|
open var requestConfigConfigCallsCount: Int {
|
|
get { requestConfigConfigCallsCountLock.withLock { requestConfigConfigUnderlyingCallsCount } }
|
|
set { requestConfigConfigCallsCountLock.withLock { requestConfigConfigUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var requestConfigConfigCalled: Bool {
|
|
return requestConfigConfigCallsCount > 0
|
|
}
|
|
private let requestConfigConfigReceivedConfigLock = NSLock()
|
|
private var requestConfigConfigUnderlyingReceivedConfig: RequestConfig?
|
|
open var requestConfigConfigReceivedConfig: RequestConfig? {
|
|
get { requestConfigConfigReceivedConfigLock.withLock { requestConfigConfigUnderlyingReceivedConfig } }
|
|
set { requestConfigConfigReceivedConfigLock.withLock { requestConfigConfigUnderlyingReceivedConfig = newValue } }
|
|
}
|
|
private let requestConfigConfigReceivedInvocationsLock = NSLock()
|
|
private var requestConfigConfigUnderlyingReceivedInvocations: [RequestConfig] = []
|
|
open var requestConfigConfigReceivedInvocations: [RequestConfig] {
|
|
get { requestConfigConfigReceivedInvocationsLock.withLock { requestConfigConfigUnderlyingReceivedInvocations } }
|
|
set { requestConfigConfigReceivedInvocationsLock.withLock { requestConfigConfigUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let requestConfigConfigReturnValueLock = NSLock()
|
|
open var requestConfigConfigUnderlyingReturnValue: ClientBuilder!
|
|
open var requestConfigConfigReturnValue: ClientBuilder! {
|
|
get { requestConfigConfigReturnValueLock.withLock { requestConfigConfigUnderlyingReturnValue } }
|
|
set { requestConfigConfigReturnValueLock.withLock { requestConfigConfigUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var requestConfigConfigClosure: ((RequestConfig) -> ClientBuilder)?
|
|
|
|
open override func requestConfig(config: RequestConfig) -> ClientBuilder {
|
|
requestConfigConfigCallsCountLock.withLock { requestConfigConfigUnderlyingCallsCount += 1 }
|
|
requestConfigConfigReceivedConfig = config
|
|
requestConfigConfigReceivedInvocationsLock.withLock { requestConfigConfigUnderlyingReceivedInvocations.append(config) }
|
|
if let requestConfigConfigClosure = requestConfigConfigClosure {
|
|
return requestConfigConfigClosure(config)
|
|
} else {
|
|
return requestConfigConfigReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - roomKeyRecipientStrategy
|
|
|
|
private let roomKeyRecipientStrategyStrategyCallsCountLock = NSLock()
|
|
private var roomKeyRecipientStrategyStrategyUnderlyingCallsCount = 0
|
|
open var roomKeyRecipientStrategyStrategyCallsCount: Int {
|
|
get { roomKeyRecipientStrategyStrategyCallsCountLock.withLock { roomKeyRecipientStrategyStrategyUnderlyingCallsCount } }
|
|
set { roomKeyRecipientStrategyStrategyCallsCountLock.withLock { roomKeyRecipientStrategyStrategyUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var roomKeyRecipientStrategyStrategyCalled: Bool {
|
|
return roomKeyRecipientStrategyStrategyCallsCount > 0
|
|
}
|
|
private let roomKeyRecipientStrategyStrategyReceivedStrategyLock = NSLock()
|
|
private var roomKeyRecipientStrategyStrategyUnderlyingReceivedStrategy: CollectStrategy?
|
|
open var roomKeyRecipientStrategyStrategyReceivedStrategy: CollectStrategy? {
|
|
get { roomKeyRecipientStrategyStrategyReceivedStrategyLock.withLock { roomKeyRecipientStrategyStrategyUnderlyingReceivedStrategy } }
|
|
set { roomKeyRecipientStrategyStrategyReceivedStrategyLock.withLock { roomKeyRecipientStrategyStrategyUnderlyingReceivedStrategy = newValue } }
|
|
}
|
|
private let roomKeyRecipientStrategyStrategyReceivedInvocationsLock = NSLock()
|
|
private var roomKeyRecipientStrategyStrategyUnderlyingReceivedInvocations: [CollectStrategy] = []
|
|
open var roomKeyRecipientStrategyStrategyReceivedInvocations: [CollectStrategy] {
|
|
get { roomKeyRecipientStrategyStrategyReceivedInvocationsLock.withLock { roomKeyRecipientStrategyStrategyUnderlyingReceivedInvocations } }
|
|
set { roomKeyRecipientStrategyStrategyReceivedInvocationsLock.withLock { roomKeyRecipientStrategyStrategyUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let roomKeyRecipientStrategyStrategyReturnValueLock = NSLock()
|
|
open var roomKeyRecipientStrategyStrategyUnderlyingReturnValue: ClientBuilder!
|
|
open var roomKeyRecipientStrategyStrategyReturnValue: ClientBuilder! {
|
|
get { roomKeyRecipientStrategyStrategyReturnValueLock.withLock { roomKeyRecipientStrategyStrategyUnderlyingReturnValue } }
|
|
set { roomKeyRecipientStrategyStrategyReturnValueLock.withLock { roomKeyRecipientStrategyStrategyUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var roomKeyRecipientStrategyStrategyClosure: ((CollectStrategy) -> ClientBuilder)?
|
|
|
|
open override func roomKeyRecipientStrategy(strategy: CollectStrategy) -> ClientBuilder {
|
|
roomKeyRecipientStrategyStrategyCallsCountLock.withLock { roomKeyRecipientStrategyStrategyUnderlyingCallsCount += 1 }
|
|
roomKeyRecipientStrategyStrategyReceivedStrategy = strategy
|
|
roomKeyRecipientStrategyStrategyReceivedInvocationsLock.withLock { roomKeyRecipientStrategyStrategyUnderlyingReceivedInvocations.append(strategy) }
|
|
if let roomKeyRecipientStrategyStrategyClosure = roomKeyRecipientStrategyStrategyClosure {
|
|
return roomKeyRecipientStrategyStrategyClosure(strategy)
|
|
} else {
|
|
return roomKeyRecipientStrategyStrategyReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - serverName
|
|
|
|
private let serverNameServerNameCallsCountLock = NSLock()
|
|
private var serverNameServerNameUnderlyingCallsCount = 0
|
|
open var serverNameServerNameCallsCount: Int {
|
|
get { serverNameServerNameCallsCountLock.withLock { serverNameServerNameUnderlyingCallsCount } }
|
|
set { serverNameServerNameCallsCountLock.withLock { serverNameServerNameUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var serverNameServerNameCalled: Bool {
|
|
return serverNameServerNameCallsCount > 0
|
|
}
|
|
private let serverNameServerNameReceivedServerNameLock = NSLock()
|
|
private var serverNameServerNameUnderlyingReceivedServerName: String?
|
|
open var serverNameServerNameReceivedServerName: String? {
|
|
get { serverNameServerNameReceivedServerNameLock.withLock { serverNameServerNameUnderlyingReceivedServerName } }
|
|
set { serverNameServerNameReceivedServerNameLock.withLock { serverNameServerNameUnderlyingReceivedServerName = newValue } }
|
|
}
|
|
private let serverNameServerNameReceivedInvocationsLock = NSLock()
|
|
private var serverNameServerNameUnderlyingReceivedInvocations: [String] = []
|
|
open var serverNameServerNameReceivedInvocations: [String] {
|
|
get { serverNameServerNameReceivedInvocationsLock.withLock { serverNameServerNameUnderlyingReceivedInvocations } }
|
|
set { serverNameServerNameReceivedInvocationsLock.withLock { serverNameServerNameUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let serverNameServerNameReturnValueLock = NSLock()
|
|
open var serverNameServerNameUnderlyingReturnValue: ClientBuilder!
|
|
open var serverNameServerNameReturnValue: ClientBuilder! {
|
|
get { serverNameServerNameReturnValueLock.withLock { serverNameServerNameUnderlyingReturnValue } }
|
|
set { serverNameServerNameReturnValueLock.withLock { serverNameServerNameUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var serverNameServerNameClosure: ((String) -> ClientBuilder)?
|
|
|
|
open override func serverName(serverName: String) -> ClientBuilder {
|
|
serverNameServerNameCallsCountLock.withLock { serverNameServerNameUnderlyingCallsCount += 1 }
|
|
serverNameServerNameReceivedServerName = serverName
|
|
serverNameServerNameReceivedInvocationsLock.withLock { serverNameServerNameUnderlyingReceivedInvocations.append(serverName) }
|
|
if let serverNameServerNameClosure = serverNameServerNameClosure {
|
|
return serverNameServerNameClosure(serverName)
|
|
} else {
|
|
return serverNameServerNameReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - serverNameOrHomeserverUrl
|
|
|
|
private let serverNameOrHomeserverUrlServerNameOrUrlCallsCountLock = NSLock()
|
|
private var serverNameOrHomeserverUrlServerNameOrUrlUnderlyingCallsCount = 0
|
|
open var serverNameOrHomeserverUrlServerNameOrUrlCallsCount: Int {
|
|
get { serverNameOrHomeserverUrlServerNameOrUrlCallsCountLock.withLock { serverNameOrHomeserverUrlServerNameOrUrlUnderlyingCallsCount } }
|
|
set { serverNameOrHomeserverUrlServerNameOrUrlCallsCountLock.withLock { serverNameOrHomeserverUrlServerNameOrUrlUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var serverNameOrHomeserverUrlServerNameOrUrlCalled: Bool {
|
|
return serverNameOrHomeserverUrlServerNameOrUrlCallsCount > 0
|
|
}
|
|
private let serverNameOrHomeserverUrlServerNameOrUrlReceivedServerNameOrUrlLock = NSLock()
|
|
private var serverNameOrHomeserverUrlServerNameOrUrlUnderlyingReceivedServerNameOrUrl: String?
|
|
open var serverNameOrHomeserverUrlServerNameOrUrlReceivedServerNameOrUrl: String? {
|
|
get { serverNameOrHomeserverUrlServerNameOrUrlReceivedServerNameOrUrlLock.withLock { serverNameOrHomeserverUrlServerNameOrUrlUnderlyingReceivedServerNameOrUrl } }
|
|
set { serverNameOrHomeserverUrlServerNameOrUrlReceivedServerNameOrUrlLock.withLock { serverNameOrHomeserverUrlServerNameOrUrlUnderlyingReceivedServerNameOrUrl = newValue } }
|
|
}
|
|
private let serverNameOrHomeserverUrlServerNameOrUrlReceivedInvocationsLock = NSLock()
|
|
private var serverNameOrHomeserverUrlServerNameOrUrlUnderlyingReceivedInvocations: [String] = []
|
|
open var serverNameOrHomeserverUrlServerNameOrUrlReceivedInvocations: [String] {
|
|
get { serverNameOrHomeserverUrlServerNameOrUrlReceivedInvocationsLock.withLock { serverNameOrHomeserverUrlServerNameOrUrlUnderlyingReceivedInvocations } }
|
|
set { serverNameOrHomeserverUrlServerNameOrUrlReceivedInvocationsLock.withLock { serverNameOrHomeserverUrlServerNameOrUrlUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let serverNameOrHomeserverUrlServerNameOrUrlReturnValueLock = NSLock()
|
|
open var serverNameOrHomeserverUrlServerNameOrUrlUnderlyingReturnValue: ClientBuilder!
|
|
open var serverNameOrHomeserverUrlServerNameOrUrlReturnValue: ClientBuilder! {
|
|
get { serverNameOrHomeserverUrlServerNameOrUrlReturnValueLock.withLock { serverNameOrHomeserverUrlServerNameOrUrlUnderlyingReturnValue } }
|
|
set { serverNameOrHomeserverUrlServerNameOrUrlReturnValueLock.withLock { serverNameOrHomeserverUrlServerNameOrUrlUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var serverNameOrHomeserverUrlServerNameOrUrlClosure: ((String) -> ClientBuilder)?
|
|
|
|
open override func serverNameOrHomeserverUrl(serverNameOrUrl: String) -> ClientBuilder {
|
|
serverNameOrHomeserverUrlServerNameOrUrlCallsCountLock.withLock { serverNameOrHomeserverUrlServerNameOrUrlUnderlyingCallsCount += 1 }
|
|
serverNameOrHomeserverUrlServerNameOrUrlReceivedServerNameOrUrl = serverNameOrUrl
|
|
serverNameOrHomeserverUrlServerNameOrUrlReceivedInvocationsLock.withLock { serverNameOrHomeserverUrlServerNameOrUrlUnderlyingReceivedInvocations.append(serverNameOrUrl) }
|
|
if let serverNameOrHomeserverUrlServerNameOrUrlClosure = serverNameOrHomeserverUrlServerNameOrUrlClosure {
|
|
return serverNameOrHomeserverUrlServerNameOrUrlClosure(serverNameOrUrl)
|
|
} else {
|
|
return serverNameOrHomeserverUrlServerNameOrUrlReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - sessionPaths
|
|
|
|
private let sessionPathsDataPathCachePathCallsCountLock = NSLock()
|
|
private var sessionPathsDataPathCachePathUnderlyingCallsCount = 0
|
|
open var sessionPathsDataPathCachePathCallsCount: Int {
|
|
get { sessionPathsDataPathCachePathCallsCountLock.withLock { sessionPathsDataPathCachePathUnderlyingCallsCount } }
|
|
set { sessionPathsDataPathCachePathCallsCountLock.withLock { sessionPathsDataPathCachePathUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var sessionPathsDataPathCachePathCalled: Bool {
|
|
return sessionPathsDataPathCachePathCallsCount > 0
|
|
}
|
|
private let sessionPathsDataPathCachePathReceivedArgumentsLock = NSLock()
|
|
private var sessionPathsDataPathCachePathUnderlyingReceivedArguments: (dataPath: String, cachePath: String)?
|
|
open var sessionPathsDataPathCachePathReceivedArguments: (dataPath: String, cachePath: String)? {
|
|
get { sessionPathsDataPathCachePathReceivedArgumentsLock.withLock { sessionPathsDataPathCachePathUnderlyingReceivedArguments } }
|
|
set { sessionPathsDataPathCachePathReceivedArgumentsLock.withLock { sessionPathsDataPathCachePathUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let sessionPathsDataPathCachePathReceivedInvocationsLock = NSLock()
|
|
private var sessionPathsDataPathCachePathUnderlyingReceivedInvocations: [(dataPath: String, cachePath: String)] = []
|
|
open var sessionPathsDataPathCachePathReceivedInvocations: [(dataPath: String, cachePath: String)] {
|
|
get { sessionPathsDataPathCachePathReceivedInvocationsLock.withLock { sessionPathsDataPathCachePathUnderlyingReceivedInvocations } }
|
|
set { sessionPathsDataPathCachePathReceivedInvocationsLock.withLock { sessionPathsDataPathCachePathUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let sessionPathsDataPathCachePathReturnValueLock = NSLock()
|
|
open var sessionPathsDataPathCachePathUnderlyingReturnValue: ClientBuilder!
|
|
open var sessionPathsDataPathCachePathReturnValue: ClientBuilder! {
|
|
get { sessionPathsDataPathCachePathReturnValueLock.withLock { sessionPathsDataPathCachePathUnderlyingReturnValue } }
|
|
set { sessionPathsDataPathCachePathReturnValueLock.withLock { sessionPathsDataPathCachePathUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var sessionPathsDataPathCachePathClosure: ((String, String) -> ClientBuilder)?
|
|
|
|
open override func sessionPaths(dataPath: String, cachePath: String) -> ClientBuilder {
|
|
sessionPathsDataPathCachePathCallsCountLock.withLock { sessionPathsDataPathCachePathUnderlyingCallsCount += 1 }
|
|
sessionPathsDataPathCachePathReceivedArguments = (dataPath: dataPath, cachePath: cachePath)
|
|
sessionPathsDataPathCachePathReceivedInvocationsLock.withLock { sessionPathsDataPathCachePathUnderlyingReceivedInvocations.append((dataPath: dataPath, cachePath: cachePath)) }
|
|
if let sessionPathsDataPathCachePathClosure = sessionPathsDataPathCachePathClosure {
|
|
return sessionPathsDataPathCachePathClosure(dataPath, cachePath)
|
|
} else {
|
|
return sessionPathsDataPathCachePathReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - setSessionDelegate
|
|
|
|
private let setSessionDelegateSessionDelegateCallsCountLock = NSLock()
|
|
private var setSessionDelegateSessionDelegateUnderlyingCallsCount = 0
|
|
open var setSessionDelegateSessionDelegateCallsCount: Int {
|
|
get { setSessionDelegateSessionDelegateCallsCountLock.withLock { setSessionDelegateSessionDelegateUnderlyingCallsCount } }
|
|
set { setSessionDelegateSessionDelegateCallsCountLock.withLock { setSessionDelegateSessionDelegateUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var setSessionDelegateSessionDelegateCalled: Bool {
|
|
return setSessionDelegateSessionDelegateCallsCount > 0
|
|
}
|
|
private let setSessionDelegateSessionDelegateReceivedSessionDelegateLock = NSLock()
|
|
private var setSessionDelegateSessionDelegateUnderlyingReceivedSessionDelegate: ClientSessionDelegate?
|
|
open var setSessionDelegateSessionDelegateReceivedSessionDelegate: ClientSessionDelegate? {
|
|
get { setSessionDelegateSessionDelegateReceivedSessionDelegateLock.withLock { setSessionDelegateSessionDelegateUnderlyingReceivedSessionDelegate } }
|
|
set { setSessionDelegateSessionDelegateReceivedSessionDelegateLock.withLock { setSessionDelegateSessionDelegateUnderlyingReceivedSessionDelegate = newValue } }
|
|
}
|
|
private let setSessionDelegateSessionDelegateReceivedInvocationsLock = NSLock()
|
|
private var setSessionDelegateSessionDelegateUnderlyingReceivedInvocations: [ClientSessionDelegate] = []
|
|
open var setSessionDelegateSessionDelegateReceivedInvocations: [ClientSessionDelegate] {
|
|
get { setSessionDelegateSessionDelegateReceivedInvocationsLock.withLock { setSessionDelegateSessionDelegateUnderlyingReceivedInvocations } }
|
|
set { setSessionDelegateSessionDelegateReceivedInvocationsLock.withLock { setSessionDelegateSessionDelegateUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let setSessionDelegateSessionDelegateReturnValueLock = NSLock()
|
|
open var setSessionDelegateSessionDelegateUnderlyingReturnValue: ClientBuilder!
|
|
open var setSessionDelegateSessionDelegateReturnValue: ClientBuilder! {
|
|
get { setSessionDelegateSessionDelegateReturnValueLock.withLock { setSessionDelegateSessionDelegateUnderlyingReturnValue } }
|
|
set { setSessionDelegateSessionDelegateReturnValueLock.withLock { setSessionDelegateSessionDelegateUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var setSessionDelegateSessionDelegateClosure: ((ClientSessionDelegate) -> ClientBuilder)?
|
|
|
|
open override func setSessionDelegate(sessionDelegate: ClientSessionDelegate) -> ClientBuilder {
|
|
setSessionDelegateSessionDelegateCallsCountLock.withLock { setSessionDelegateSessionDelegateUnderlyingCallsCount += 1 }
|
|
setSessionDelegateSessionDelegateReceivedSessionDelegate = sessionDelegate
|
|
setSessionDelegateSessionDelegateReceivedInvocationsLock.withLock { setSessionDelegateSessionDelegateUnderlyingReceivedInvocations.append(sessionDelegate) }
|
|
if let setSessionDelegateSessionDelegateClosure = setSessionDelegateSessionDelegateClosure {
|
|
return setSessionDelegateSessionDelegateClosure(sessionDelegate)
|
|
} else {
|
|
return setSessionDelegateSessionDelegateReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - slidingSyncVersionBuilder
|
|
|
|
private let slidingSyncVersionBuilderVersionBuilderCallsCountLock = NSLock()
|
|
private var slidingSyncVersionBuilderVersionBuilderUnderlyingCallsCount = 0
|
|
open var slidingSyncVersionBuilderVersionBuilderCallsCount: Int {
|
|
get { slidingSyncVersionBuilderVersionBuilderCallsCountLock.withLock { slidingSyncVersionBuilderVersionBuilderUnderlyingCallsCount } }
|
|
set { slidingSyncVersionBuilderVersionBuilderCallsCountLock.withLock { slidingSyncVersionBuilderVersionBuilderUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var slidingSyncVersionBuilderVersionBuilderCalled: Bool {
|
|
return slidingSyncVersionBuilderVersionBuilderCallsCount > 0
|
|
}
|
|
private let slidingSyncVersionBuilderVersionBuilderReceivedVersionBuilderLock = NSLock()
|
|
private var slidingSyncVersionBuilderVersionBuilderUnderlyingReceivedVersionBuilder: SlidingSyncVersionBuilder?
|
|
open var slidingSyncVersionBuilderVersionBuilderReceivedVersionBuilder: SlidingSyncVersionBuilder? {
|
|
get { slidingSyncVersionBuilderVersionBuilderReceivedVersionBuilderLock.withLock { slidingSyncVersionBuilderVersionBuilderUnderlyingReceivedVersionBuilder } }
|
|
set { slidingSyncVersionBuilderVersionBuilderReceivedVersionBuilderLock.withLock { slidingSyncVersionBuilderVersionBuilderUnderlyingReceivedVersionBuilder = newValue } }
|
|
}
|
|
private let slidingSyncVersionBuilderVersionBuilderReceivedInvocationsLock = NSLock()
|
|
private var slidingSyncVersionBuilderVersionBuilderUnderlyingReceivedInvocations: [SlidingSyncVersionBuilder] = []
|
|
open var slidingSyncVersionBuilderVersionBuilderReceivedInvocations: [SlidingSyncVersionBuilder] {
|
|
get { slidingSyncVersionBuilderVersionBuilderReceivedInvocationsLock.withLock { slidingSyncVersionBuilderVersionBuilderUnderlyingReceivedInvocations } }
|
|
set { slidingSyncVersionBuilderVersionBuilderReceivedInvocationsLock.withLock { slidingSyncVersionBuilderVersionBuilderUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let slidingSyncVersionBuilderVersionBuilderReturnValueLock = NSLock()
|
|
open var slidingSyncVersionBuilderVersionBuilderUnderlyingReturnValue: ClientBuilder!
|
|
open var slidingSyncVersionBuilderVersionBuilderReturnValue: ClientBuilder! {
|
|
get { slidingSyncVersionBuilderVersionBuilderReturnValueLock.withLock { slidingSyncVersionBuilderVersionBuilderUnderlyingReturnValue } }
|
|
set { slidingSyncVersionBuilderVersionBuilderReturnValueLock.withLock { slidingSyncVersionBuilderVersionBuilderUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var slidingSyncVersionBuilderVersionBuilderClosure: ((SlidingSyncVersionBuilder) -> ClientBuilder)?
|
|
|
|
open override func slidingSyncVersionBuilder(versionBuilder: SlidingSyncVersionBuilder) -> ClientBuilder {
|
|
slidingSyncVersionBuilderVersionBuilderCallsCountLock.withLock { slidingSyncVersionBuilderVersionBuilderUnderlyingCallsCount += 1 }
|
|
slidingSyncVersionBuilderVersionBuilderReceivedVersionBuilder = versionBuilder
|
|
slidingSyncVersionBuilderVersionBuilderReceivedInvocationsLock.withLock { slidingSyncVersionBuilderVersionBuilderUnderlyingReceivedInvocations.append(versionBuilder) }
|
|
if let slidingSyncVersionBuilderVersionBuilderClosure = slidingSyncVersionBuilderVersionBuilderClosure {
|
|
return slidingSyncVersionBuilderVersionBuilderClosure(versionBuilder)
|
|
} else {
|
|
return slidingSyncVersionBuilderVersionBuilderReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - sqliteStore
|
|
|
|
private let sqliteStoreConfigCallsCountLock = NSLock()
|
|
private var sqliteStoreConfigUnderlyingCallsCount = 0
|
|
open var sqliteStoreConfigCallsCount: Int {
|
|
get { sqliteStoreConfigCallsCountLock.withLock { sqliteStoreConfigUnderlyingCallsCount } }
|
|
set { sqliteStoreConfigCallsCountLock.withLock { sqliteStoreConfigUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var sqliteStoreConfigCalled: Bool {
|
|
return sqliteStoreConfigCallsCount > 0
|
|
}
|
|
private let sqliteStoreConfigReceivedConfigLock = NSLock()
|
|
private var sqliteStoreConfigUnderlyingReceivedConfig: SqliteStoreBuilder?
|
|
open var sqliteStoreConfigReceivedConfig: SqliteStoreBuilder? {
|
|
get { sqliteStoreConfigReceivedConfigLock.withLock { sqliteStoreConfigUnderlyingReceivedConfig } }
|
|
set { sqliteStoreConfigReceivedConfigLock.withLock { sqliteStoreConfigUnderlyingReceivedConfig = newValue } }
|
|
}
|
|
private let sqliteStoreConfigReceivedInvocationsLock = NSLock()
|
|
private var sqliteStoreConfigUnderlyingReceivedInvocations: [SqliteStoreBuilder] = []
|
|
open var sqliteStoreConfigReceivedInvocations: [SqliteStoreBuilder] {
|
|
get { sqliteStoreConfigReceivedInvocationsLock.withLock { sqliteStoreConfigUnderlyingReceivedInvocations } }
|
|
set { sqliteStoreConfigReceivedInvocationsLock.withLock { sqliteStoreConfigUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let sqliteStoreConfigReturnValueLock = NSLock()
|
|
open var sqliteStoreConfigUnderlyingReturnValue: ClientBuilder!
|
|
open var sqliteStoreConfigReturnValue: ClientBuilder! {
|
|
get { sqliteStoreConfigReturnValueLock.withLock { sqliteStoreConfigUnderlyingReturnValue } }
|
|
set { sqliteStoreConfigReturnValueLock.withLock { sqliteStoreConfigUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var sqliteStoreConfigClosure: ((SqliteStoreBuilder) -> ClientBuilder)?
|
|
|
|
open override func sqliteStore(config: SqliteStoreBuilder) -> ClientBuilder {
|
|
sqliteStoreConfigCallsCountLock.withLock { sqliteStoreConfigUnderlyingCallsCount += 1 }
|
|
sqliteStoreConfigReceivedConfig = config
|
|
sqliteStoreConfigReceivedInvocationsLock.withLock { sqliteStoreConfigUnderlyingReceivedInvocations.append(config) }
|
|
if let sqliteStoreConfigClosure = sqliteStoreConfigClosure {
|
|
return sqliteStoreConfigClosure(config)
|
|
} else {
|
|
return sqliteStoreConfigReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - systemIsMemoryConstrained
|
|
|
|
private let systemIsMemoryConstrainedCallsCountLock = NSLock()
|
|
private var systemIsMemoryConstrainedUnderlyingCallsCount = 0
|
|
open var systemIsMemoryConstrainedCallsCount: Int {
|
|
get { systemIsMemoryConstrainedCallsCountLock.withLock { systemIsMemoryConstrainedUnderlyingCallsCount } }
|
|
set { systemIsMemoryConstrainedCallsCountLock.withLock { systemIsMemoryConstrainedUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var systemIsMemoryConstrainedCalled: Bool {
|
|
return systemIsMemoryConstrainedCallsCount > 0
|
|
}
|
|
|
|
private let systemIsMemoryConstrainedReturnValueLock = NSLock()
|
|
open var systemIsMemoryConstrainedUnderlyingReturnValue: ClientBuilder!
|
|
open var systemIsMemoryConstrainedReturnValue: ClientBuilder! {
|
|
get { systemIsMemoryConstrainedReturnValueLock.withLock { systemIsMemoryConstrainedUnderlyingReturnValue } }
|
|
set { systemIsMemoryConstrainedReturnValueLock.withLock { systemIsMemoryConstrainedUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var systemIsMemoryConstrainedClosure: (() -> ClientBuilder)?
|
|
|
|
open override func systemIsMemoryConstrained() -> ClientBuilder {
|
|
systemIsMemoryConstrainedCallsCountLock.withLock { systemIsMemoryConstrainedUnderlyingCallsCount += 1 }
|
|
if let systemIsMemoryConstrainedClosure = systemIsMemoryConstrainedClosure {
|
|
return systemIsMemoryConstrainedClosure()
|
|
} else {
|
|
return systemIsMemoryConstrainedReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - threadsEnabled
|
|
|
|
private let threadsEnabledEnabledThreadSubscriptionsCallsCountLock = NSLock()
|
|
private var threadsEnabledEnabledThreadSubscriptionsUnderlyingCallsCount = 0
|
|
open var threadsEnabledEnabledThreadSubscriptionsCallsCount: Int {
|
|
get { threadsEnabledEnabledThreadSubscriptionsCallsCountLock.withLock { threadsEnabledEnabledThreadSubscriptionsUnderlyingCallsCount } }
|
|
set { threadsEnabledEnabledThreadSubscriptionsCallsCountLock.withLock { threadsEnabledEnabledThreadSubscriptionsUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var threadsEnabledEnabledThreadSubscriptionsCalled: Bool {
|
|
return threadsEnabledEnabledThreadSubscriptionsCallsCount > 0
|
|
}
|
|
private let threadsEnabledEnabledThreadSubscriptionsReceivedArgumentsLock = NSLock()
|
|
private var threadsEnabledEnabledThreadSubscriptionsUnderlyingReceivedArguments: (enabled: Bool, threadSubscriptions: Bool)?
|
|
open var threadsEnabledEnabledThreadSubscriptionsReceivedArguments: (enabled: Bool, threadSubscriptions: Bool)? {
|
|
get { threadsEnabledEnabledThreadSubscriptionsReceivedArgumentsLock.withLock { threadsEnabledEnabledThreadSubscriptionsUnderlyingReceivedArguments } }
|
|
set { threadsEnabledEnabledThreadSubscriptionsReceivedArgumentsLock.withLock { threadsEnabledEnabledThreadSubscriptionsUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let threadsEnabledEnabledThreadSubscriptionsReceivedInvocationsLock = NSLock()
|
|
private var threadsEnabledEnabledThreadSubscriptionsUnderlyingReceivedInvocations: [(enabled: Bool, threadSubscriptions: Bool)] = []
|
|
open var threadsEnabledEnabledThreadSubscriptionsReceivedInvocations: [(enabled: Bool, threadSubscriptions: Bool)] {
|
|
get { threadsEnabledEnabledThreadSubscriptionsReceivedInvocationsLock.withLock { threadsEnabledEnabledThreadSubscriptionsUnderlyingReceivedInvocations } }
|
|
set { threadsEnabledEnabledThreadSubscriptionsReceivedInvocationsLock.withLock { threadsEnabledEnabledThreadSubscriptionsUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let threadsEnabledEnabledThreadSubscriptionsReturnValueLock = NSLock()
|
|
open var threadsEnabledEnabledThreadSubscriptionsUnderlyingReturnValue: ClientBuilder!
|
|
open var threadsEnabledEnabledThreadSubscriptionsReturnValue: ClientBuilder! {
|
|
get { threadsEnabledEnabledThreadSubscriptionsReturnValueLock.withLock { threadsEnabledEnabledThreadSubscriptionsUnderlyingReturnValue } }
|
|
set { threadsEnabledEnabledThreadSubscriptionsReturnValueLock.withLock { threadsEnabledEnabledThreadSubscriptionsUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var threadsEnabledEnabledThreadSubscriptionsClosure: ((Bool, Bool) -> ClientBuilder)?
|
|
|
|
open override func threadsEnabled(enabled: Bool, threadSubscriptions: Bool) -> ClientBuilder {
|
|
threadsEnabledEnabledThreadSubscriptionsCallsCountLock.withLock { threadsEnabledEnabledThreadSubscriptionsUnderlyingCallsCount += 1 }
|
|
threadsEnabledEnabledThreadSubscriptionsReceivedArguments = (enabled: enabled, threadSubscriptions: threadSubscriptions)
|
|
threadsEnabledEnabledThreadSubscriptionsReceivedInvocationsLock.withLock { threadsEnabledEnabledThreadSubscriptionsUnderlyingReceivedInvocations.append((enabled: enabled, threadSubscriptions: threadSubscriptions)) }
|
|
if let threadsEnabledEnabledThreadSubscriptionsClosure = threadsEnabledEnabledThreadSubscriptionsClosure {
|
|
return threadsEnabledEnabledThreadSubscriptionsClosure(enabled, threadSubscriptions)
|
|
} else {
|
|
return threadsEnabledEnabledThreadSubscriptionsReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - userAgent
|
|
|
|
private let userAgentUserAgentCallsCountLock = NSLock()
|
|
private var userAgentUserAgentUnderlyingCallsCount = 0
|
|
open var userAgentUserAgentCallsCount: Int {
|
|
get { userAgentUserAgentCallsCountLock.withLock { userAgentUserAgentUnderlyingCallsCount } }
|
|
set { userAgentUserAgentCallsCountLock.withLock { userAgentUserAgentUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var userAgentUserAgentCalled: Bool {
|
|
return userAgentUserAgentCallsCount > 0
|
|
}
|
|
private let userAgentUserAgentReceivedUserAgentLock = NSLock()
|
|
private var userAgentUserAgentUnderlyingReceivedUserAgent: String?
|
|
open var userAgentUserAgentReceivedUserAgent: String? {
|
|
get { userAgentUserAgentReceivedUserAgentLock.withLock { userAgentUserAgentUnderlyingReceivedUserAgent } }
|
|
set { userAgentUserAgentReceivedUserAgentLock.withLock { userAgentUserAgentUnderlyingReceivedUserAgent = newValue } }
|
|
}
|
|
private let userAgentUserAgentReceivedInvocationsLock = NSLock()
|
|
private var userAgentUserAgentUnderlyingReceivedInvocations: [String] = []
|
|
open var userAgentUserAgentReceivedInvocations: [String] {
|
|
get { userAgentUserAgentReceivedInvocationsLock.withLock { userAgentUserAgentUnderlyingReceivedInvocations } }
|
|
set { userAgentUserAgentReceivedInvocationsLock.withLock { userAgentUserAgentUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let userAgentUserAgentReturnValueLock = NSLock()
|
|
open var userAgentUserAgentUnderlyingReturnValue: ClientBuilder!
|
|
open var userAgentUserAgentReturnValue: ClientBuilder! {
|
|
get { userAgentUserAgentReturnValueLock.withLock { userAgentUserAgentUnderlyingReturnValue } }
|
|
set { userAgentUserAgentReturnValueLock.withLock { userAgentUserAgentUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var userAgentUserAgentClosure: ((String) -> ClientBuilder)?
|
|
|
|
open override func userAgent(userAgent: String) -> ClientBuilder {
|
|
userAgentUserAgentCallsCountLock.withLock { userAgentUserAgentUnderlyingCallsCount += 1 }
|
|
userAgentUserAgentReceivedUserAgent = userAgent
|
|
userAgentUserAgentReceivedInvocationsLock.withLock { userAgentUserAgentUnderlyingReceivedInvocations.append(userAgent) }
|
|
if let userAgentUserAgentClosure = userAgentUserAgentClosure {
|
|
return userAgentUserAgentClosure(userAgent)
|
|
} else {
|
|
return userAgentUserAgentReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - username
|
|
|
|
private let usernameUsernameCallsCountLock = NSLock()
|
|
private var usernameUsernameUnderlyingCallsCount = 0
|
|
open var usernameUsernameCallsCount: Int {
|
|
get { usernameUsernameCallsCountLock.withLock { usernameUsernameUnderlyingCallsCount } }
|
|
set { usernameUsernameCallsCountLock.withLock { usernameUsernameUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var usernameUsernameCalled: Bool {
|
|
return usernameUsernameCallsCount > 0
|
|
}
|
|
private let usernameUsernameReceivedUsernameLock = NSLock()
|
|
private var usernameUsernameUnderlyingReceivedUsername: String?
|
|
open var usernameUsernameReceivedUsername: String? {
|
|
get { usernameUsernameReceivedUsernameLock.withLock { usernameUsernameUnderlyingReceivedUsername } }
|
|
set { usernameUsernameReceivedUsernameLock.withLock { usernameUsernameUnderlyingReceivedUsername = newValue } }
|
|
}
|
|
private let usernameUsernameReceivedInvocationsLock = NSLock()
|
|
private var usernameUsernameUnderlyingReceivedInvocations: [String] = []
|
|
open var usernameUsernameReceivedInvocations: [String] {
|
|
get { usernameUsernameReceivedInvocationsLock.withLock { usernameUsernameUnderlyingReceivedInvocations } }
|
|
set { usernameUsernameReceivedInvocationsLock.withLock { usernameUsernameUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let usernameUsernameReturnValueLock = NSLock()
|
|
open var usernameUsernameUnderlyingReturnValue: ClientBuilder!
|
|
open var usernameUsernameReturnValue: ClientBuilder! {
|
|
get { usernameUsernameReturnValueLock.withLock { usernameUsernameUnderlyingReturnValue } }
|
|
set { usernameUsernameReturnValueLock.withLock { usernameUsernameUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var usernameUsernameClosure: ((String) -> ClientBuilder)?
|
|
|
|
open override func username(username: String) -> ClientBuilder {
|
|
usernameUsernameCallsCountLock.withLock { usernameUsernameUnderlyingCallsCount += 1 }
|
|
usernameUsernameReceivedUsername = username
|
|
usernameUsernameReceivedInvocationsLock.withLock { usernameUsernameUnderlyingReceivedInvocations.append(username) }
|
|
if let usernameUsernameClosure = usernameUsernameClosure {
|
|
return usernameUsernameClosure(username)
|
|
} else {
|
|
return usernameUsernameReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - withSearchIndexStore
|
|
|
|
private let withSearchIndexStorePathPasswordCallsCountLock = NSLock()
|
|
private var withSearchIndexStorePathPasswordUnderlyingCallsCount = 0
|
|
open var withSearchIndexStorePathPasswordCallsCount: Int {
|
|
get { withSearchIndexStorePathPasswordCallsCountLock.withLock { withSearchIndexStorePathPasswordUnderlyingCallsCount } }
|
|
set { withSearchIndexStorePathPasswordCallsCountLock.withLock { withSearchIndexStorePathPasswordUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var withSearchIndexStorePathPasswordCalled: Bool {
|
|
return withSearchIndexStorePathPasswordCallsCount > 0
|
|
}
|
|
private let withSearchIndexStorePathPasswordReceivedArgumentsLock = NSLock()
|
|
private var withSearchIndexStorePathPasswordUnderlyingReceivedArguments: (path: String, password: String?)?
|
|
open var withSearchIndexStorePathPasswordReceivedArguments: (path: String, password: String?)? {
|
|
get { withSearchIndexStorePathPasswordReceivedArgumentsLock.withLock { withSearchIndexStorePathPasswordUnderlyingReceivedArguments } }
|
|
set { withSearchIndexStorePathPasswordReceivedArgumentsLock.withLock { withSearchIndexStorePathPasswordUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let withSearchIndexStorePathPasswordReceivedInvocationsLock = NSLock()
|
|
private var withSearchIndexStorePathPasswordUnderlyingReceivedInvocations: [(path: String, password: String?)] = []
|
|
open var withSearchIndexStorePathPasswordReceivedInvocations: [(path: String, password: String?)] {
|
|
get { withSearchIndexStorePathPasswordReceivedInvocationsLock.withLock { withSearchIndexStorePathPasswordUnderlyingReceivedInvocations } }
|
|
set { withSearchIndexStorePathPasswordReceivedInvocationsLock.withLock { withSearchIndexStorePathPasswordUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let withSearchIndexStorePathPasswordReturnValueLock = NSLock()
|
|
open var withSearchIndexStorePathPasswordUnderlyingReturnValue: ClientBuilder!
|
|
open var withSearchIndexStorePathPasswordReturnValue: ClientBuilder! {
|
|
get { withSearchIndexStorePathPasswordReturnValueLock.withLock { withSearchIndexStorePathPasswordUnderlyingReturnValue } }
|
|
set { withSearchIndexStorePathPasswordReturnValueLock.withLock { withSearchIndexStorePathPasswordUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var withSearchIndexStorePathPasswordClosure: ((String, String?) -> ClientBuilder)?
|
|
|
|
open override func withSearchIndexStore(path: String, password: String?) -> ClientBuilder {
|
|
withSearchIndexStorePathPasswordCallsCountLock.withLock { withSearchIndexStorePathPasswordUnderlyingCallsCount += 1 }
|
|
withSearchIndexStorePathPasswordReceivedArguments = (path: path, password: password)
|
|
withSearchIndexStorePathPasswordReceivedInvocationsLock.withLock { withSearchIndexStorePathPasswordUnderlyingReceivedInvocations.append((path: path, password: password)) }
|
|
if let withSearchIndexStorePathPasswordClosure = withSearchIndexStorePathPasswordClosure {
|
|
return withSearchIndexStorePathPasswordClosure(path, password)
|
|
} else {
|
|
return withSearchIndexStorePathPasswordReturnValue
|
|
}
|
|
}
|
|
}
|
|
open class ContentScannerSDKMock: MatrixRustSDK.ContentScanner, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
|
|
//MARK: - scan
|
|
|
|
open var scanClientMediaSourceThrowableError: Error?
|
|
private let scanClientMediaSourceCallsCountLock = NSLock()
|
|
private var scanClientMediaSourceUnderlyingCallsCount = 0
|
|
open var scanClientMediaSourceCallsCount: Int {
|
|
get { scanClientMediaSourceCallsCountLock.withLock { scanClientMediaSourceUnderlyingCallsCount } }
|
|
set { scanClientMediaSourceCallsCountLock.withLock { scanClientMediaSourceUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var scanClientMediaSourceCalled: Bool {
|
|
return scanClientMediaSourceCallsCount > 0
|
|
}
|
|
private let scanClientMediaSourceReceivedArgumentsLock = NSLock()
|
|
private var scanClientMediaSourceUnderlyingReceivedArguments: (client: Client, mediaSource: MediaSource)?
|
|
open var scanClientMediaSourceReceivedArguments: (client: Client, mediaSource: MediaSource)? {
|
|
get { scanClientMediaSourceReceivedArgumentsLock.withLock { scanClientMediaSourceUnderlyingReceivedArguments } }
|
|
set { scanClientMediaSourceReceivedArgumentsLock.withLock { scanClientMediaSourceUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let scanClientMediaSourceReceivedInvocationsLock = NSLock()
|
|
private var scanClientMediaSourceUnderlyingReceivedInvocations: [(client: Client, mediaSource: MediaSource)] = []
|
|
open var scanClientMediaSourceReceivedInvocations: [(client: Client, mediaSource: MediaSource)] {
|
|
get { scanClientMediaSourceReceivedInvocationsLock.withLock { scanClientMediaSourceUnderlyingReceivedInvocations } }
|
|
set { scanClientMediaSourceReceivedInvocationsLock.withLock { scanClientMediaSourceUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let scanClientMediaSourceReturnValueLock = NSLock()
|
|
open var scanClientMediaSourceUnderlyingReturnValue: MediaScanResponse!
|
|
open var scanClientMediaSourceReturnValue: MediaScanResponse! {
|
|
get { scanClientMediaSourceReturnValueLock.withLock { scanClientMediaSourceUnderlyingReturnValue } }
|
|
set { scanClientMediaSourceReturnValueLock.withLock { scanClientMediaSourceUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var scanClientMediaSourceClosure: ((Client, MediaSource) async throws -> MediaScanResponse)?
|
|
|
|
open override func scan(client: Client, mediaSource: MediaSource) async throws -> MediaScanResponse {
|
|
if let error = scanClientMediaSourceThrowableError {
|
|
throw error
|
|
}
|
|
scanClientMediaSourceCallsCountLock.withLock { scanClientMediaSourceUnderlyingCallsCount += 1 }
|
|
scanClientMediaSourceReceivedArguments = (client: client, mediaSource: mediaSource)
|
|
scanClientMediaSourceReceivedInvocationsLock.withLock { scanClientMediaSourceUnderlyingReceivedInvocations.append((client: client, mediaSource: mediaSource)) }
|
|
if let scanClientMediaSourceClosure = scanClientMediaSourceClosure {
|
|
return try await scanClientMediaSourceClosure(client, mediaSource)
|
|
} else {
|
|
return scanClientMediaSourceReturnValue
|
|
}
|
|
}
|
|
}
|
|
open class CrossSigningSecretsSDKMock: MatrixRustSDK.CrossSigningSecrets, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
}
|
|
open class EncryptionSDKMock: MatrixRustSDK.Encryption, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
|
|
//MARK: - backupExistsOnServer
|
|
|
|
open var backupExistsOnServerThrowableError: Error?
|
|
private let backupExistsOnServerCallsCountLock = NSLock()
|
|
private var backupExistsOnServerUnderlyingCallsCount = 0
|
|
open var backupExistsOnServerCallsCount: Int {
|
|
get { backupExistsOnServerCallsCountLock.withLock { backupExistsOnServerUnderlyingCallsCount } }
|
|
set { backupExistsOnServerCallsCountLock.withLock { backupExistsOnServerUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var backupExistsOnServerCalled: Bool {
|
|
return backupExistsOnServerCallsCount > 0
|
|
}
|
|
|
|
private let backupExistsOnServerReturnValueLock = NSLock()
|
|
open var backupExistsOnServerUnderlyingReturnValue: Bool!
|
|
open var backupExistsOnServerReturnValue: Bool! {
|
|
get { backupExistsOnServerReturnValueLock.withLock { backupExistsOnServerUnderlyingReturnValue } }
|
|
set { backupExistsOnServerReturnValueLock.withLock { backupExistsOnServerUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var backupExistsOnServerClosure: (() async throws -> Bool)?
|
|
|
|
open override func backupExistsOnServer() async throws -> Bool {
|
|
if let error = backupExistsOnServerThrowableError {
|
|
throw error
|
|
}
|
|
backupExistsOnServerCallsCountLock.withLock { backupExistsOnServerUnderlyingCallsCount += 1 }
|
|
if let backupExistsOnServerClosure = backupExistsOnServerClosure {
|
|
return try await backupExistsOnServerClosure()
|
|
} else {
|
|
return backupExistsOnServerReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - backupState
|
|
|
|
private let backupStateCallsCountLock = NSLock()
|
|
private var backupStateUnderlyingCallsCount = 0
|
|
open var backupStateCallsCount: Int {
|
|
get { backupStateCallsCountLock.withLock { backupStateUnderlyingCallsCount } }
|
|
set { backupStateCallsCountLock.withLock { backupStateUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var backupStateCalled: Bool {
|
|
return backupStateCallsCount > 0
|
|
}
|
|
|
|
private let backupStateReturnValueLock = NSLock()
|
|
open var backupStateUnderlyingReturnValue: BackupState!
|
|
open var backupStateReturnValue: BackupState! {
|
|
get { backupStateReturnValueLock.withLock { backupStateUnderlyingReturnValue } }
|
|
set { backupStateReturnValueLock.withLock { backupStateUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var backupStateClosure: (() -> BackupState)?
|
|
|
|
open override func backupState() -> BackupState {
|
|
backupStateCallsCountLock.withLock { backupStateUnderlyingCallsCount += 1 }
|
|
if let backupStateClosure = backupStateClosure {
|
|
return backupStateClosure()
|
|
} else {
|
|
return backupStateReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - backupStateListener
|
|
|
|
private let backupStateListenerListenerCallsCountLock = NSLock()
|
|
private var backupStateListenerListenerUnderlyingCallsCount = 0
|
|
open var backupStateListenerListenerCallsCount: Int {
|
|
get { backupStateListenerListenerCallsCountLock.withLock { backupStateListenerListenerUnderlyingCallsCount } }
|
|
set { backupStateListenerListenerCallsCountLock.withLock { backupStateListenerListenerUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var backupStateListenerListenerCalled: Bool {
|
|
return backupStateListenerListenerCallsCount > 0
|
|
}
|
|
private let backupStateListenerListenerReceivedListenerLock = NSLock()
|
|
private var backupStateListenerListenerUnderlyingReceivedListener: BackupStateListener?
|
|
open var backupStateListenerListenerReceivedListener: BackupStateListener? {
|
|
get { backupStateListenerListenerReceivedListenerLock.withLock { backupStateListenerListenerUnderlyingReceivedListener } }
|
|
set { backupStateListenerListenerReceivedListenerLock.withLock { backupStateListenerListenerUnderlyingReceivedListener = newValue } }
|
|
}
|
|
private let backupStateListenerListenerReceivedInvocationsLock = NSLock()
|
|
private var backupStateListenerListenerUnderlyingReceivedInvocations: [BackupStateListener] = []
|
|
open var backupStateListenerListenerReceivedInvocations: [BackupStateListener] {
|
|
get { backupStateListenerListenerReceivedInvocationsLock.withLock { backupStateListenerListenerUnderlyingReceivedInvocations } }
|
|
set { backupStateListenerListenerReceivedInvocationsLock.withLock { backupStateListenerListenerUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let backupStateListenerListenerReturnValueLock = NSLock()
|
|
open var backupStateListenerListenerUnderlyingReturnValue: TaskHandle!
|
|
open var backupStateListenerListenerReturnValue: TaskHandle! {
|
|
get { backupStateListenerListenerReturnValueLock.withLock { backupStateListenerListenerUnderlyingReturnValue } }
|
|
set { backupStateListenerListenerReturnValueLock.withLock { backupStateListenerListenerUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var backupStateListenerListenerClosure: ((BackupStateListener) -> TaskHandle)?
|
|
|
|
open override func backupStateListener(listener: BackupStateListener) -> TaskHandle {
|
|
backupStateListenerListenerCallsCountLock.withLock { backupStateListenerListenerUnderlyingCallsCount += 1 }
|
|
backupStateListenerListenerReceivedListener = listener
|
|
backupStateListenerListenerReceivedInvocationsLock.withLock { backupStateListenerListenerUnderlyingReceivedInvocations.append(listener) }
|
|
if let backupStateListenerListenerClosure = backupStateListenerListenerClosure {
|
|
return backupStateListenerListenerClosure(listener)
|
|
} else {
|
|
return backupStateListenerListenerReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - curve25519Key
|
|
|
|
private let curve25519KeyCallsCountLock = NSLock()
|
|
private var curve25519KeyUnderlyingCallsCount = 0
|
|
open var curve25519KeyCallsCount: Int {
|
|
get { curve25519KeyCallsCountLock.withLock { curve25519KeyUnderlyingCallsCount } }
|
|
set { curve25519KeyCallsCountLock.withLock { curve25519KeyUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var curve25519KeyCalled: Bool {
|
|
return curve25519KeyCallsCount > 0
|
|
}
|
|
|
|
private let curve25519KeyReturnValueLock = NSLock()
|
|
open var curve25519KeyUnderlyingReturnValue: String?
|
|
open var curve25519KeyReturnValue: String? {
|
|
get { curve25519KeyReturnValueLock.withLock { curve25519KeyUnderlyingReturnValue } }
|
|
set { curve25519KeyReturnValueLock.withLock { curve25519KeyUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var curve25519KeyClosure: (() async -> String?)?
|
|
|
|
open override func curve25519Key() async -> String? {
|
|
curve25519KeyCallsCountLock.withLock { curve25519KeyUnderlyingCallsCount += 1 }
|
|
if let curve25519KeyClosure = curve25519KeyClosure {
|
|
return await curve25519KeyClosure()
|
|
} else {
|
|
return curve25519KeyReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - disableRecovery
|
|
|
|
open var disableRecoveryThrowableError: Error?
|
|
private let disableRecoveryCallsCountLock = NSLock()
|
|
private var disableRecoveryUnderlyingCallsCount = 0
|
|
open var disableRecoveryCallsCount: Int {
|
|
get { disableRecoveryCallsCountLock.withLock { disableRecoveryUnderlyingCallsCount } }
|
|
set { disableRecoveryCallsCountLock.withLock { disableRecoveryUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var disableRecoveryCalled: Bool {
|
|
return disableRecoveryCallsCount > 0
|
|
}
|
|
open var disableRecoveryClosure: (() async throws -> Void)?
|
|
|
|
open override func disableRecovery() async throws {
|
|
if let error = disableRecoveryThrowableError {
|
|
throw error
|
|
}
|
|
disableRecoveryCallsCountLock.withLock { disableRecoveryUnderlyingCallsCount += 1 }
|
|
try await disableRecoveryClosure?()
|
|
}
|
|
|
|
//MARK: - ed25519Key
|
|
|
|
private let ed25519KeyCallsCountLock = NSLock()
|
|
private var ed25519KeyUnderlyingCallsCount = 0
|
|
open var ed25519KeyCallsCount: Int {
|
|
get { ed25519KeyCallsCountLock.withLock { ed25519KeyUnderlyingCallsCount } }
|
|
set { ed25519KeyCallsCountLock.withLock { ed25519KeyUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var ed25519KeyCalled: Bool {
|
|
return ed25519KeyCallsCount > 0
|
|
}
|
|
|
|
private let ed25519KeyReturnValueLock = NSLock()
|
|
open var ed25519KeyUnderlyingReturnValue: String?
|
|
open var ed25519KeyReturnValue: String? {
|
|
get { ed25519KeyReturnValueLock.withLock { ed25519KeyUnderlyingReturnValue } }
|
|
set { ed25519KeyReturnValueLock.withLock { ed25519KeyUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var ed25519KeyClosure: (() async -> String?)?
|
|
|
|
open override func ed25519Key() async -> String? {
|
|
ed25519KeyCallsCountLock.withLock { ed25519KeyUnderlyingCallsCount += 1 }
|
|
if let ed25519KeyClosure = ed25519KeyClosure {
|
|
return await ed25519KeyClosure()
|
|
} else {
|
|
return ed25519KeyReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - enableBackups
|
|
|
|
open var enableBackupsThrowableError: Error?
|
|
private let enableBackupsCallsCountLock = NSLock()
|
|
private var enableBackupsUnderlyingCallsCount = 0
|
|
open var enableBackupsCallsCount: Int {
|
|
get { enableBackupsCallsCountLock.withLock { enableBackupsUnderlyingCallsCount } }
|
|
set { enableBackupsCallsCountLock.withLock { enableBackupsUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var enableBackupsCalled: Bool {
|
|
return enableBackupsCallsCount > 0
|
|
}
|
|
open var enableBackupsClosure: (() async throws -> Void)?
|
|
|
|
open override func enableBackups() async throws {
|
|
if let error = enableBackupsThrowableError {
|
|
throw error
|
|
}
|
|
enableBackupsCallsCountLock.withLock { enableBackupsUnderlyingCallsCount += 1 }
|
|
try await enableBackupsClosure?()
|
|
}
|
|
|
|
//MARK: - enableRecovery
|
|
|
|
open var enableRecoveryWaitForBackupsToUploadPassphraseProgressListenerThrowableError: Error?
|
|
private let enableRecoveryWaitForBackupsToUploadPassphraseProgressListenerCallsCountLock = NSLock()
|
|
private var enableRecoveryWaitForBackupsToUploadPassphraseProgressListenerUnderlyingCallsCount = 0
|
|
open var enableRecoveryWaitForBackupsToUploadPassphraseProgressListenerCallsCount: Int {
|
|
get { enableRecoveryWaitForBackupsToUploadPassphraseProgressListenerCallsCountLock.withLock { enableRecoveryWaitForBackupsToUploadPassphraseProgressListenerUnderlyingCallsCount } }
|
|
set { enableRecoveryWaitForBackupsToUploadPassphraseProgressListenerCallsCountLock.withLock { enableRecoveryWaitForBackupsToUploadPassphraseProgressListenerUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var enableRecoveryWaitForBackupsToUploadPassphraseProgressListenerCalled: Bool {
|
|
return enableRecoveryWaitForBackupsToUploadPassphraseProgressListenerCallsCount > 0
|
|
}
|
|
private let enableRecoveryWaitForBackupsToUploadPassphraseProgressListenerReceivedArgumentsLock = NSLock()
|
|
private var enableRecoveryWaitForBackupsToUploadPassphraseProgressListenerUnderlyingReceivedArguments: (waitForBackupsToUpload: Bool, passphrase: String?, progressListener: EnableRecoveryProgressListener)?
|
|
open var enableRecoveryWaitForBackupsToUploadPassphraseProgressListenerReceivedArguments: (waitForBackupsToUpload: Bool, passphrase: String?, progressListener: EnableRecoveryProgressListener)? {
|
|
get { enableRecoveryWaitForBackupsToUploadPassphraseProgressListenerReceivedArgumentsLock.withLock { enableRecoveryWaitForBackupsToUploadPassphraseProgressListenerUnderlyingReceivedArguments } }
|
|
set { enableRecoveryWaitForBackupsToUploadPassphraseProgressListenerReceivedArgumentsLock.withLock { enableRecoveryWaitForBackupsToUploadPassphraseProgressListenerUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let enableRecoveryWaitForBackupsToUploadPassphraseProgressListenerReceivedInvocationsLock = NSLock()
|
|
private var enableRecoveryWaitForBackupsToUploadPassphraseProgressListenerUnderlyingReceivedInvocations: [(waitForBackupsToUpload: Bool, passphrase: String?, progressListener: EnableRecoveryProgressListener)] = []
|
|
open var enableRecoveryWaitForBackupsToUploadPassphraseProgressListenerReceivedInvocations: [(waitForBackupsToUpload: Bool, passphrase: String?, progressListener: EnableRecoveryProgressListener)] {
|
|
get { enableRecoveryWaitForBackupsToUploadPassphraseProgressListenerReceivedInvocationsLock.withLock { enableRecoveryWaitForBackupsToUploadPassphraseProgressListenerUnderlyingReceivedInvocations } }
|
|
set { enableRecoveryWaitForBackupsToUploadPassphraseProgressListenerReceivedInvocationsLock.withLock { enableRecoveryWaitForBackupsToUploadPassphraseProgressListenerUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let enableRecoveryWaitForBackupsToUploadPassphraseProgressListenerReturnValueLock = NSLock()
|
|
open var enableRecoveryWaitForBackupsToUploadPassphraseProgressListenerUnderlyingReturnValue: String!
|
|
open var enableRecoveryWaitForBackupsToUploadPassphraseProgressListenerReturnValue: String! {
|
|
get { enableRecoveryWaitForBackupsToUploadPassphraseProgressListenerReturnValueLock.withLock { enableRecoveryWaitForBackupsToUploadPassphraseProgressListenerUnderlyingReturnValue } }
|
|
set { enableRecoveryWaitForBackupsToUploadPassphraseProgressListenerReturnValueLock.withLock { enableRecoveryWaitForBackupsToUploadPassphraseProgressListenerUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var enableRecoveryWaitForBackupsToUploadPassphraseProgressListenerClosure: ((Bool, String?, EnableRecoveryProgressListener) async throws -> String)?
|
|
|
|
open override func enableRecovery(waitForBackupsToUpload: Bool, passphrase: String?, progressListener: EnableRecoveryProgressListener) async throws -> String {
|
|
if let error = enableRecoveryWaitForBackupsToUploadPassphraseProgressListenerThrowableError {
|
|
throw error
|
|
}
|
|
enableRecoveryWaitForBackupsToUploadPassphraseProgressListenerCallsCountLock.withLock { enableRecoveryWaitForBackupsToUploadPassphraseProgressListenerUnderlyingCallsCount += 1 }
|
|
enableRecoveryWaitForBackupsToUploadPassphraseProgressListenerReceivedArguments = (waitForBackupsToUpload: waitForBackupsToUpload, passphrase: passphrase, progressListener: progressListener)
|
|
enableRecoveryWaitForBackupsToUploadPassphraseProgressListenerReceivedInvocationsLock.withLock { enableRecoveryWaitForBackupsToUploadPassphraseProgressListenerUnderlyingReceivedInvocations.append((waitForBackupsToUpload: waitForBackupsToUpload, passphrase: passphrase, progressListener: progressListener)) }
|
|
if let enableRecoveryWaitForBackupsToUploadPassphraseProgressListenerClosure = enableRecoveryWaitForBackupsToUploadPassphraseProgressListenerClosure {
|
|
return try await enableRecoveryWaitForBackupsToUploadPassphraseProgressListenerClosure(waitForBackupsToUpload, passphrase, progressListener)
|
|
} else {
|
|
return enableRecoveryWaitForBackupsToUploadPassphraseProgressListenerReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - hasDevicesToVerifyAgainst
|
|
|
|
open var hasDevicesToVerifyAgainstThrowableError: Error?
|
|
private let hasDevicesToVerifyAgainstCallsCountLock = NSLock()
|
|
private var hasDevicesToVerifyAgainstUnderlyingCallsCount = 0
|
|
open var hasDevicesToVerifyAgainstCallsCount: Int {
|
|
get { hasDevicesToVerifyAgainstCallsCountLock.withLock { hasDevicesToVerifyAgainstUnderlyingCallsCount } }
|
|
set { hasDevicesToVerifyAgainstCallsCountLock.withLock { hasDevicesToVerifyAgainstUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var hasDevicesToVerifyAgainstCalled: Bool {
|
|
return hasDevicesToVerifyAgainstCallsCount > 0
|
|
}
|
|
|
|
private let hasDevicesToVerifyAgainstReturnValueLock = NSLock()
|
|
open var hasDevicesToVerifyAgainstUnderlyingReturnValue: Bool!
|
|
open var hasDevicesToVerifyAgainstReturnValue: Bool! {
|
|
get { hasDevicesToVerifyAgainstReturnValueLock.withLock { hasDevicesToVerifyAgainstUnderlyingReturnValue } }
|
|
set { hasDevicesToVerifyAgainstReturnValueLock.withLock { hasDevicesToVerifyAgainstUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var hasDevicesToVerifyAgainstClosure: (() async throws -> Bool)?
|
|
|
|
open override func hasDevicesToVerifyAgainst() async throws -> Bool {
|
|
if let error = hasDevicesToVerifyAgainstThrowableError {
|
|
throw error
|
|
}
|
|
hasDevicesToVerifyAgainstCallsCountLock.withLock { hasDevicesToVerifyAgainstUnderlyingCallsCount += 1 }
|
|
if let hasDevicesToVerifyAgainstClosure = hasDevicesToVerifyAgainstClosure {
|
|
return try await hasDevicesToVerifyAgainstClosure()
|
|
} else {
|
|
return hasDevicesToVerifyAgainstReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - importSecretsBundle
|
|
|
|
open var importSecretsBundleSecretsBundleThrowableError: Error?
|
|
private let importSecretsBundleSecretsBundleCallsCountLock = NSLock()
|
|
private var importSecretsBundleSecretsBundleUnderlyingCallsCount = 0
|
|
open var importSecretsBundleSecretsBundleCallsCount: Int {
|
|
get { importSecretsBundleSecretsBundleCallsCountLock.withLock { importSecretsBundleSecretsBundleUnderlyingCallsCount } }
|
|
set { importSecretsBundleSecretsBundleCallsCountLock.withLock { importSecretsBundleSecretsBundleUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var importSecretsBundleSecretsBundleCalled: Bool {
|
|
return importSecretsBundleSecretsBundleCallsCount > 0
|
|
}
|
|
private let importSecretsBundleSecretsBundleReceivedSecretsBundleLock = NSLock()
|
|
private var importSecretsBundleSecretsBundleUnderlyingReceivedSecretsBundle: SecretsBundleWithUserId?
|
|
open var importSecretsBundleSecretsBundleReceivedSecretsBundle: SecretsBundleWithUserId? {
|
|
get { importSecretsBundleSecretsBundleReceivedSecretsBundleLock.withLock { importSecretsBundleSecretsBundleUnderlyingReceivedSecretsBundle } }
|
|
set { importSecretsBundleSecretsBundleReceivedSecretsBundleLock.withLock { importSecretsBundleSecretsBundleUnderlyingReceivedSecretsBundle = newValue } }
|
|
}
|
|
private let importSecretsBundleSecretsBundleReceivedInvocationsLock = NSLock()
|
|
private var importSecretsBundleSecretsBundleUnderlyingReceivedInvocations: [SecretsBundleWithUserId] = []
|
|
open var importSecretsBundleSecretsBundleReceivedInvocations: [SecretsBundleWithUserId] {
|
|
get { importSecretsBundleSecretsBundleReceivedInvocationsLock.withLock { importSecretsBundleSecretsBundleUnderlyingReceivedInvocations } }
|
|
set { importSecretsBundleSecretsBundleReceivedInvocationsLock.withLock { importSecretsBundleSecretsBundleUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var importSecretsBundleSecretsBundleClosure: ((SecretsBundleWithUserId) async throws -> Void)?
|
|
|
|
open override func importSecretsBundle(secretsBundle: SecretsBundleWithUserId) async throws {
|
|
if let error = importSecretsBundleSecretsBundleThrowableError {
|
|
throw error
|
|
}
|
|
importSecretsBundleSecretsBundleCallsCountLock.withLock { importSecretsBundleSecretsBundleUnderlyingCallsCount += 1 }
|
|
importSecretsBundleSecretsBundleReceivedSecretsBundle = secretsBundle
|
|
importSecretsBundleSecretsBundleReceivedInvocationsLock.withLock { importSecretsBundleSecretsBundleUnderlyingReceivedInvocations.append(secretsBundle) }
|
|
try await importSecretsBundleSecretsBundleClosure?(secretsBundle)
|
|
}
|
|
|
|
//MARK: - isLastDevice
|
|
|
|
open var isLastDeviceThrowableError: Error?
|
|
private let isLastDeviceCallsCountLock = NSLock()
|
|
private var isLastDeviceUnderlyingCallsCount = 0
|
|
open var isLastDeviceCallsCount: Int {
|
|
get { isLastDeviceCallsCountLock.withLock { isLastDeviceUnderlyingCallsCount } }
|
|
set { isLastDeviceCallsCountLock.withLock { isLastDeviceUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var isLastDeviceCalled: Bool {
|
|
return isLastDeviceCallsCount > 0
|
|
}
|
|
|
|
private let isLastDeviceReturnValueLock = NSLock()
|
|
open var isLastDeviceUnderlyingReturnValue: Bool!
|
|
open var isLastDeviceReturnValue: Bool! {
|
|
get { isLastDeviceReturnValueLock.withLock { isLastDeviceUnderlyingReturnValue } }
|
|
set { isLastDeviceReturnValueLock.withLock { isLastDeviceUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var isLastDeviceClosure: (() async throws -> Bool)?
|
|
|
|
open override func isLastDevice() async throws -> Bool {
|
|
if let error = isLastDeviceThrowableError {
|
|
throw error
|
|
}
|
|
isLastDeviceCallsCountLock.withLock { isLastDeviceUnderlyingCallsCount += 1 }
|
|
if let isLastDeviceClosure = isLastDeviceClosure {
|
|
return try await isLastDeviceClosure()
|
|
} else {
|
|
return isLastDeviceReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - recover
|
|
|
|
open var recoverRecoveryKeyThrowableError: Error?
|
|
private let recoverRecoveryKeyCallsCountLock = NSLock()
|
|
private var recoverRecoveryKeyUnderlyingCallsCount = 0
|
|
open var recoverRecoveryKeyCallsCount: Int {
|
|
get { recoverRecoveryKeyCallsCountLock.withLock { recoverRecoveryKeyUnderlyingCallsCount } }
|
|
set { recoverRecoveryKeyCallsCountLock.withLock { recoverRecoveryKeyUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var recoverRecoveryKeyCalled: Bool {
|
|
return recoverRecoveryKeyCallsCount > 0
|
|
}
|
|
private let recoverRecoveryKeyReceivedRecoveryKeyLock = NSLock()
|
|
private var recoverRecoveryKeyUnderlyingReceivedRecoveryKey: String?
|
|
open var recoverRecoveryKeyReceivedRecoveryKey: String? {
|
|
get { recoverRecoveryKeyReceivedRecoveryKeyLock.withLock { recoverRecoveryKeyUnderlyingReceivedRecoveryKey } }
|
|
set { recoverRecoveryKeyReceivedRecoveryKeyLock.withLock { recoverRecoveryKeyUnderlyingReceivedRecoveryKey = newValue } }
|
|
}
|
|
private let recoverRecoveryKeyReceivedInvocationsLock = NSLock()
|
|
private var recoverRecoveryKeyUnderlyingReceivedInvocations: [String] = []
|
|
open var recoverRecoveryKeyReceivedInvocations: [String] {
|
|
get { recoverRecoveryKeyReceivedInvocationsLock.withLock { recoverRecoveryKeyUnderlyingReceivedInvocations } }
|
|
set { recoverRecoveryKeyReceivedInvocationsLock.withLock { recoverRecoveryKeyUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var recoverRecoveryKeyClosure: ((String) async throws -> Void)?
|
|
|
|
open override func recover(recoveryKey: String) async throws {
|
|
if let error = recoverRecoveryKeyThrowableError {
|
|
throw error
|
|
}
|
|
recoverRecoveryKeyCallsCountLock.withLock { recoverRecoveryKeyUnderlyingCallsCount += 1 }
|
|
recoverRecoveryKeyReceivedRecoveryKey = recoveryKey
|
|
recoverRecoveryKeyReceivedInvocationsLock.withLock { recoverRecoveryKeyUnderlyingReceivedInvocations.append(recoveryKey) }
|
|
try await recoverRecoveryKeyClosure?(recoveryKey)
|
|
}
|
|
|
|
//MARK: - recoverAndFixBackup
|
|
|
|
open var recoverAndFixBackupRecoveryKeyThrowableError: Error?
|
|
private let recoverAndFixBackupRecoveryKeyCallsCountLock = NSLock()
|
|
private var recoverAndFixBackupRecoveryKeyUnderlyingCallsCount = 0
|
|
open var recoverAndFixBackupRecoveryKeyCallsCount: Int {
|
|
get { recoverAndFixBackupRecoveryKeyCallsCountLock.withLock { recoverAndFixBackupRecoveryKeyUnderlyingCallsCount } }
|
|
set { recoverAndFixBackupRecoveryKeyCallsCountLock.withLock { recoverAndFixBackupRecoveryKeyUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var recoverAndFixBackupRecoveryKeyCalled: Bool {
|
|
return recoverAndFixBackupRecoveryKeyCallsCount > 0
|
|
}
|
|
private let recoverAndFixBackupRecoveryKeyReceivedRecoveryKeyLock = NSLock()
|
|
private var recoverAndFixBackupRecoveryKeyUnderlyingReceivedRecoveryKey: String?
|
|
open var recoverAndFixBackupRecoveryKeyReceivedRecoveryKey: String? {
|
|
get { recoverAndFixBackupRecoveryKeyReceivedRecoveryKeyLock.withLock { recoverAndFixBackupRecoveryKeyUnderlyingReceivedRecoveryKey } }
|
|
set { recoverAndFixBackupRecoveryKeyReceivedRecoveryKeyLock.withLock { recoverAndFixBackupRecoveryKeyUnderlyingReceivedRecoveryKey = newValue } }
|
|
}
|
|
private let recoverAndFixBackupRecoveryKeyReceivedInvocationsLock = NSLock()
|
|
private var recoverAndFixBackupRecoveryKeyUnderlyingReceivedInvocations: [String] = []
|
|
open var recoverAndFixBackupRecoveryKeyReceivedInvocations: [String] {
|
|
get { recoverAndFixBackupRecoveryKeyReceivedInvocationsLock.withLock { recoverAndFixBackupRecoveryKeyUnderlyingReceivedInvocations } }
|
|
set { recoverAndFixBackupRecoveryKeyReceivedInvocationsLock.withLock { recoverAndFixBackupRecoveryKeyUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var recoverAndFixBackupRecoveryKeyClosure: ((String) async throws -> Void)?
|
|
|
|
open override func recoverAndFixBackup(recoveryKey: String) async throws {
|
|
if let error = recoverAndFixBackupRecoveryKeyThrowableError {
|
|
throw error
|
|
}
|
|
recoverAndFixBackupRecoveryKeyCallsCountLock.withLock { recoverAndFixBackupRecoveryKeyUnderlyingCallsCount += 1 }
|
|
recoverAndFixBackupRecoveryKeyReceivedRecoveryKey = recoveryKey
|
|
recoverAndFixBackupRecoveryKeyReceivedInvocationsLock.withLock { recoverAndFixBackupRecoveryKeyUnderlyingReceivedInvocations.append(recoveryKey) }
|
|
try await recoverAndFixBackupRecoveryKeyClosure?(recoveryKey)
|
|
}
|
|
|
|
//MARK: - recoverAndReset
|
|
|
|
open var recoverAndResetOldRecoveryKeyThrowableError: Error?
|
|
private let recoverAndResetOldRecoveryKeyCallsCountLock = NSLock()
|
|
private var recoverAndResetOldRecoveryKeyUnderlyingCallsCount = 0
|
|
open var recoverAndResetOldRecoveryKeyCallsCount: Int {
|
|
get { recoverAndResetOldRecoveryKeyCallsCountLock.withLock { recoverAndResetOldRecoveryKeyUnderlyingCallsCount } }
|
|
set { recoverAndResetOldRecoveryKeyCallsCountLock.withLock { recoverAndResetOldRecoveryKeyUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var recoverAndResetOldRecoveryKeyCalled: Bool {
|
|
return recoverAndResetOldRecoveryKeyCallsCount > 0
|
|
}
|
|
private let recoverAndResetOldRecoveryKeyReceivedOldRecoveryKeyLock = NSLock()
|
|
private var recoverAndResetOldRecoveryKeyUnderlyingReceivedOldRecoveryKey: String?
|
|
open var recoverAndResetOldRecoveryKeyReceivedOldRecoveryKey: String? {
|
|
get { recoverAndResetOldRecoveryKeyReceivedOldRecoveryKeyLock.withLock { recoverAndResetOldRecoveryKeyUnderlyingReceivedOldRecoveryKey } }
|
|
set { recoverAndResetOldRecoveryKeyReceivedOldRecoveryKeyLock.withLock { recoverAndResetOldRecoveryKeyUnderlyingReceivedOldRecoveryKey = newValue } }
|
|
}
|
|
private let recoverAndResetOldRecoveryKeyReceivedInvocationsLock = NSLock()
|
|
private var recoverAndResetOldRecoveryKeyUnderlyingReceivedInvocations: [String] = []
|
|
open var recoverAndResetOldRecoveryKeyReceivedInvocations: [String] {
|
|
get { recoverAndResetOldRecoveryKeyReceivedInvocationsLock.withLock { recoverAndResetOldRecoveryKeyUnderlyingReceivedInvocations } }
|
|
set { recoverAndResetOldRecoveryKeyReceivedInvocationsLock.withLock { recoverAndResetOldRecoveryKeyUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let recoverAndResetOldRecoveryKeyReturnValueLock = NSLock()
|
|
open var recoverAndResetOldRecoveryKeyUnderlyingReturnValue: String!
|
|
open var recoverAndResetOldRecoveryKeyReturnValue: String! {
|
|
get { recoverAndResetOldRecoveryKeyReturnValueLock.withLock { recoverAndResetOldRecoveryKeyUnderlyingReturnValue } }
|
|
set { recoverAndResetOldRecoveryKeyReturnValueLock.withLock { recoverAndResetOldRecoveryKeyUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var recoverAndResetOldRecoveryKeyClosure: ((String) async throws -> String)?
|
|
|
|
open override func recoverAndReset(oldRecoveryKey: String) async throws -> String {
|
|
if let error = recoverAndResetOldRecoveryKeyThrowableError {
|
|
throw error
|
|
}
|
|
recoverAndResetOldRecoveryKeyCallsCountLock.withLock { recoverAndResetOldRecoveryKeyUnderlyingCallsCount += 1 }
|
|
recoverAndResetOldRecoveryKeyReceivedOldRecoveryKey = oldRecoveryKey
|
|
recoverAndResetOldRecoveryKeyReceivedInvocationsLock.withLock { recoverAndResetOldRecoveryKeyUnderlyingReceivedInvocations.append(oldRecoveryKey) }
|
|
if let recoverAndResetOldRecoveryKeyClosure = recoverAndResetOldRecoveryKeyClosure {
|
|
return try await recoverAndResetOldRecoveryKeyClosure(oldRecoveryKey)
|
|
} else {
|
|
return recoverAndResetOldRecoveryKeyReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - recoveryState
|
|
|
|
private let recoveryStateCallsCountLock = NSLock()
|
|
private var recoveryStateUnderlyingCallsCount = 0
|
|
open var recoveryStateCallsCount: Int {
|
|
get { recoveryStateCallsCountLock.withLock { recoveryStateUnderlyingCallsCount } }
|
|
set { recoveryStateCallsCountLock.withLock { recoveryStateUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var recoveryStateCalled: Bool {
|
|
return recoveryStateCallsCount > 0
|
|
}
|
|
|
|
private let recoveryStateReturnValueLock = NSLock()
|
|
open var recoveryStateUnderlyingReturnValue: RecoveryState!
|
|
open var recoveryStateReturnValue: RecoveryState! {
|
|
get { recoveryStateReturnValueLock.withLock { recoveryStateUnderlyingReturnValue } }
|
|
set { recoveryStateReturnValueLock.withLock { recoveryStateUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var recoveryStateClosure: (() -> RecoveryState)?
|
|
|
|
open override func recoveryState() -> RecoveryState {
|
|
recoveryStateCallsCountLock.withLock { recoveryStateUnderlyingCallsCount += 1 }
|
|
if let recoveryStateClosure = recoveryStateClosure {
|
|
return recoveryStateClosure()
|
|
} else {
|
|
return recoveryStateReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - recoveryStateListener
|
|
|
|
private let recoveryStateListenerListenerCallsCountLock = NSLock()
|
|
private var recoveryStateListenerListenerUnderlyingCallsCount = 0
|
|
open var recoveryStateListenerListenerCallsCount: Int {
|
|
get { recoveryStateListenerListenerCallsCountLock.withLock { recoveryStateListenerListenerUnderlyingCallsCount } }
|
|
set { recoveryStateListenerListenerCallsCountLock.withLock { recoveryStateListenerListenerUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var recoveryStateListenerListenerCalled: Bool {
|
|
return recoveryStateListenerListenerCallsCount > 0
|
|
}
|
|
private let recoveryStateListenerListenerReceivedListenerLock = NSLock()
|
|
private var recoveryStateListenerListenerUnderlyingReceivedListener: RecoveryStateListener?
|
|
open var recoveryStateListenerListenerReceivedListener: RecoveryStateListener? {
|
|
get { recoveryStateListenerListenerReceivedListenerLock.withLock { recoveryStateListenerListenerUnderlyingReceivedListener } }
|
|
set { recoveryStateListenerListenerReceivedListenerLock.withLock { recoveryStateListenerListenerUnderlyingReceivedListener = newValue } }
|
|
}
|
|
private let recoveryStateListenerListenerReceivedInvocationsLock = NSLock()
|
|
private var recoveryStateListenerListenerUnderlyingReceivedInvocations: [RecoveryStateListener] = []
|
|
open var recoveryStateListenerListenerReceivedInvocations: [RecoveryStateListener] {
|
|
get { recoveryStateListenerListenerReceivedInvocationsLock.withLock { recoveryStateListenerListenerUnderlyingReceivedInvocations } }
|
|
set { recoveryStateListenerListenerReceivedInvocationsLock.withLock { recoveryStateListenerListenerUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let recoveryStateListenerListenerReturnValueLock = NSLock()
|
|
open var recoveryStateListenerListenerUnderlyingReturnValue: TaskHandle!
|
|
open var recoveryStateListenerListenerReturnValue: TaskHandle! {
|
|
get { recoveryStateListenerListenerReturnValueLock.withLock { recoveryStateListenerListenerUnderlyingReturnValue } }
|
|
set { recoveryStateListenerListenerReturnValueLock.withLock { recoveryStateListenerListenerUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var recoveryStateListenerListenerClosure: ((RecoveryStateListener) -> TaskHandle)?
|
|
|
|
open override func recoveryStateListener(listener: RecoveryStateListener) -> TaskHandle {
|
|
recoveryStateListenerListenerCallsCountLock.withLock { recoveryStateListenerListenerUnderlyingCallsCount += 1 }
|
|
recoveryStateListenerListenerReceivedListener = listener
|
|
recoveryStateListenerListenerReceivedInvocationsLock.withLock { recoveryStateListenerListenerUnderlyingReceivedInvocations.append(listener) }
|
|
if let recoveryStateListenerListenerClosure = recoveryStateListenerListenerClosure {
|
|
return recoveryStateListenerListenerClosure(listener)
|
|
} else {
|
|
return recoveryStateListenerListenerReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - resetIdentity
|
|
|
|
open var resetIdentityThrowableError: Error?
|
|
private let resetIdentityCallsCountLock = NSLock()
|
|
private var resetIdentityUnderlyingCallsCount = 0
|
|
open var resetIdentityCallsCount: Int {
|
|
get { resetIdentityCallsCountLock.withLock { resetIdentityUnderlyingCallsCount } }
|
|
set { resetIdentityCallsCountLock.withLock { resetIdentityUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var resetIdentityCalled: Bool {
|
|
return resetIdentityCallsCount > 0
|
|
}
|
|
|
|
private let resetIdentityReturnValueLock = NSLock()
|
|
open var resetIdentityUnderlyingReturnValue: IdentityResetHandle?
|
|
open var resetIdentityReturnValue: IdentityResetHandle? {
|
|
get { resetIdentityReturnValueLock.withLock { resetIdentityUnderlyingReturnValue } }
|
|
set { resetIdentityReturnValueLock.withLock { resetIdentityUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var resetIdentityClosure: (() async throws -> IdentityResetHandle?)?
|
|
|
|
open override func resetIdentity() async throws -> IdentityResetHandle? {
|
|
if let error = resetIdentityThrowableError {
|
|
throw error
|
|
}
|
|
resetIdentityCallsCountLock.withLock { resetIdentityUnderlyingCallsCount += 1 }
|
|
if let resetIdentityClosure = resetIdentityClosure {
|
|
return try await resetIdentityClosure()
|
|
} else {
|
|
return resetIdentityReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - resetRecoveryKey
|
|
|
|
open var resetRecoveryKeyThrowableError: Error?
|
|
private let resetRecoveryKeyCallsCountLock = NSLock()
|
|
private var resetRecoveryKeyUnderlyingCallsCount = 0
|
|
open var resetRecoveryKeyCallsCount: Int {
|
|
get { resetRecoveryKeyCallsCountLock.withLock { resetRecoveryKeyUnderlyingCallsCount } }
|
|
set { resetRecoveryKeyCallsCountLock.withLock { resetRecoveryKeyUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var resetRecoveryKeyCalled: Bool {
|
|
return resetRecoveryKeyCallsCount > 0
|
|
}
|
|
|
|
private let resetRecoveryKeyReturnValueLock = NSLock()
|
|
open var resetRecoveryKeyUnderlyingReturnValue: String!
|
|
open var resetRecoveryKeyReturnValue: String! {
|
|
get { resetRecoveryKeyReturnValueLock.withLock { resetRecoveryKeyUnderlyingReturnValue } }
|
|
set { resetRecoveryKeyReturnValueLock.withLock { resetRecoveryKeyUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var resetRecoveryKeyClosure: (() async throws -> String)?
|
|
|
|
open override func resetRecoveryKey() async throws -> String {
|
|
if let error = resetRecoveryKeyThrowableError {
|
|
throw error
|
|
}
|
|
resetRecoveryKeyCallsCountLock.withLock { resetRecoveryKeyUnderlyingCallsCount += 1 }
|
|
if let resetRecoveryKeyClosure = resetRecoveryKeyClosure {
|
|
return try await resetRecoveryKeyClosure()
|
|
} else {
|
|
return resetRecoveryKeyReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - userIdentity
|
|
|
|
open var userIdentityUserIdFallbackToServerThrowableError: Error?
|
|
private let userIdentityUserIdFallbackToServerCallsCountLock = NSLock()
|
|
private var userIdentityUserIdFallbackToServerUnderlyingCallsCount = 0
|
|
open var userIdentityUserIdFallbackToServerCallsCount: Int {
|
|
get { userIdentityUserIdFallbackToServerCallsCountLock.withLock { userIdentityUserIdFallbackToServerUnderlyingCallsCount } }
|
|
set { userIdentityUserIdFallbackToServerCallsCountLock.withLock { userIdentityUserIdFallbackToServerUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var userIdentityUserIdFallbackToServerCalled: Bool {
|
|
return userIdentityUserIdFallbackToServerCallsCount > 0
|
|
}
|
|
private let userIdentityUserIdFallbackToServerReceivedArgumentsLock = NSLock()
|
|
private var userIdentityUserIdFallbackToServerUnderlyingReceivedArguments: (userId: String, fallbackToServer: Bool)?
|
|
open var userIdentityUserIdFallbackToServerReceivedArguments: (userId: String, fallbackToServer: Bool)? {
|
|
get { userIdentityUserIdFallbackToServerReceivedArgumentsLock.withLock { userIdentityUserIdFallbackToServerUnderlyingReceivedArguments } }
|
|
set { userIdentityUserIdFallbackToServerReceivedArgumentsLock.withLock { userIdentityUserIdFallbackToServerUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let userIdentityUserIdFallbackToServerReceivedInvocationsLock = NSLock()
|
|
private var userIdentityUserIdFallbackToServerUnderlyingReceivedInvocations: [(userId: String, fallbackToServer: Bool)] = []
|
|
open var userIdentityUserIdFallbackToServerReceivedInvocations: [(userId: String, fallbackToServer: Bool)] {
|
|
get { userIdentityUserIdFallbackToServerReceivedInvocationsLock.withLock { userIdentityUserIdFallbackToServerUnderlyingReceivedInvocations } }
|
|
set { userIdentityUserIdFallbackToServerReceivedInvocationsLock.withLock { userIdentityUserIdFallbackToServerUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let userIdentityUserIdFallbackToServerReturnValueLock = NSLock()
|
|
open var userIdentityUserIdFallbackToServerUnderlyingReturnValue: UserIdentity?
|
|
open var userIdentityUserIdFallbackToServerReturnValue: UserIdentity? {
|
|
get { userIdentityUserIdFallbackToServerReturnValueLock.withLock { userIdentityUserIdFallbackToServerUnderlyingReturnValue } }
|
|
set { userIdentityUserIdFallbackToServerReturnValueLock.withLock { userIdentityUserIdFallbackToServerUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var userIdentityUserIdFallbackToServerClosure: ((String, Bool) async throws -> UserIdentity?)?
|
|
|
|
open override func userIdentity(userId: String, fallbackToServer: Bool) async throws -> UserIdentity? {
|
|
if let error = userIdentityUserIdFallbackToServerThrowableError {
|
|
throw error
|
|
}
|
|
userIdentityUserIdFallbackToServerCallsCountLock.withLock { userIdentityUserIdFallbackToServerUnderlyingCallsCount += 1 }
|
|
userIdentityUserIdFallbackToServerReceivedArguments = (userId: userId, fallbackToServer: fallbackToServer)
|
|
userIdentityUserIdFallbackToServerReceivedInvocationsLock.withLock { userIdentityUserIdFallbackToServerUnderlyingReceivedInvocations.append((userId: userId, fallbackToServer: fallbackToServer)) }
|
|
if let userIdentityUserIdFallbackToServerClosure = userIdentityUserIdFallbackToServerClosure {
|
|
return try await userIdentityUserIdFallbackToServerClosure(userId, fallbackToServer)
|
|
} else {
|
|
return userIdentityUserIdFallbackToServerReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - verificationState
|
|
|
|
private let verificationStateCallsCountLock = NSLock()
|
|
private var verificationStateUnderlyingCallsCount = 0
|
|
open var verificationStateCallsCount: Int {
|
|
get { verificationStateCallsCountLock.withLock { verificationStateUnderlyingCallsCount } }
|
|
set { verificationStateCallsCountLock.withLock { verificationStateUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var verificationStateCalled: Bool {
|
|
return verificationStateCallsCount > 0
|
|
}
|
|
|
|
private let verificationStateReturnValueLock = NSLock()
|
|
open var verificationStateUnderlyingReturnValue: VerificationState!
|
|
open var verificationStateReturnValue: VerificationState! {
|
|
get { verificationStateReturnValueLock.withLock { verificationStateUnderlyingReturnValue } }
|
|
set { verificationStateReturnValueLock.withLock { verificationStateUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var verificationStateClosure: (() -> VerificationState)?
|
|
|
|
open override func verificationState() -> VerificationState {
|
|
verificationStateCallsCountLock.withLock { verificationStateUnderlyingCallsCount += 1 }
|
|
if let verificationStateClosure = verificationStateClosure {
|
|
return verificationStateClosure()
|
|
} else {
|
|
return verificationStateReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - verificationStateListener
|
|
|
|
private let verificationStateListenerListenerCallsCountLock = NSLock()
|
|
private var verificationStateListenerListenerUnderlyingCallsCount = 0
|
|
open var verificationStateListenerListenerCallsCount: Int {
|
|
get { verificationStateListenerListenerCallsCountLock.withLock { verificationStateListenerListenerUnderlyingCallsCount } }
|
|
set { verificationStateListenerListenerCallsCountLock.withLock { verificationStateListenerListenerUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var verificationStateListenerListenerCalled: Bool {
|
|
return verificationStateListenerListenerCallsCount > 0
|
|
}
|
|
private let verificationStateListenerListenerReceivedListenerLock = NSLock()
|
|
private var verificationStateListenerListenerUnderlyingReceivedListener: VerificationStateListener?
|
|
open var verificationStateListenerListenerReceivedListener: VerificationStateListener? {
|
|
get { verificationStateListenerListenerReceivedListenerLock.withLock { verificationStateListenerListenerUnderlyingReceivedListener } }
|
|
set { verificationStateListenerListenerReceivedListenerLock.withLock { verificationStateListenerListenerUnderlyingReceivedListener = newValue } }
|
|
}
|
|
private let verificationStateListenerListenerReceivedInvocationsLock = NSLock()
|
|
private var verificationStateListenerListenerUnderlyingReceivedInvocations: [VerificationStateListener] = []
|
|
open var verificationStateListenerListenerReceivedInvocations: [VerificationStateListener] {
|
|
get { verificationStateListenerListenerReceivedInvocationsLock.withLock { verificationStateListenerListenerUnderlyingReceivedInvocations } }
|
|
set { verificationStateListenerListenerReceivedInvocationsLock.withLock { verificationStateListenerListenerUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let verificationStateListenerListenerReturnValueLock = NSLock()
|
|
open var verificationStateListenerListenerUnderlyingReturnValue: TaskHandle!
|
|
open var verificationStateListenerListenerReturnValue: TaskHandle! {
|
|
get { verificationStateListenerListenerReturnValueLock.withLock { verificationStateListenerListenerUnderlyingReturnValue } }
|
|
set { verificationStateListenerListenerReturnValueLock.withLock { verificationStateListenerListenerUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var verificationStateListenerListenerClosure: ((VerificationStateListener) -> TaskHandle)?
|
|
|
|
open override func verificationStateListener(listener: VerificationStateListener) -> TaskHandle {
|
|
verificationStateListenerListenerCallsCountLock.withLock { verificationStateListenerListenerUnderlyingCallsCount += 1 }
|
|
verificationStateListenerListenerReceivedListener = listener
|
|
verificationStateListenerListenerReceivedInvocationsLock.withLock { verificationStateListenerListenerUnderlyingReceivedInvocations.append(listener) }
|
|
if let verificationStateListenerListenerClosure = verificationStateListenerListenerClosure {
|
|
return verificationStateListenerListenerClosure(listener)
|
|
} else {
|
|
return verificationStateListenerListenerReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - waitForBackupUploadSteadyState
|
|
|
|
open var waitForBackupUploadSteadyStateProgressListenerThrowableError: Error?
|
|
private let waitForBackupUploadSteadyStateProgressListenerCallsCountLock = NSLock()
|
|
private var waitForBackupUploadSteadyStateProgressListenerUnderlyingCallsCount = 0
|
|
open var waitForBackupUploadSteadyStateProgressListenerCallsCount: Int {
|
|
get { waitForBackupUploadSteadyStateProgressListenerCallsCountLock.withLock { waitForBackupUploadSteadyStateProgressListenerUnderlyingCallsCount } }
|
|
set { waitForBackupUploadSteadyStateProgressListenerCallsCountLock.withLock { waitForBackupUploadSteadyStateProgressListenerUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var waitForBackupUploadSteadyStateProgressListenerCalled: Bool {
|
|
return waitForBackupUploadSteadyStateProgressListenerCallsCount > 0
|
|
}
|
|
private let waitForBackupUploadSteadyStateProgressListenerReceivedProgressListenerLock = NSLock()
|
|
private var waitForBackupUploadSteadyStateProgressListenerUnderlyingReceivedProgressListener: BackupSteadyStateListener?
|
|
open var waitForBackupUploadSteadyStateProgressListenerReceivedProgressListener: BackupSteadyStateListener? {
|
|
get { waitForBackupUploadSteadyStateProgressListenerReceivedProgressListenerLock.withLock { waitForBackupUploadSteadyStateProgressListenerUnderlyingReceivedProgressListener } }
|
|
set { waitForBackupUploadSteadyStateProgressListenerReceivedProgressListenerLock.withLock { waitForBackupUploadSteadyStateProgressListenerUnderlyingReceivedProgressListener = newValue } }
|
|
}
|
|
private let waitForBackupUploadSteadyStateProgressListenerReceivedInvocationsLock = NSLock()
|
|
private var waitForBackupUploadSteadyStateProgressListenerUnderlyingReceivedInvocations: [BackupSteadyStateListener?] = []
|
|
open var waitForBackupUploadSteadyStateProgressListenerReceivedInvocations: [BackupSteadyStateListener?] {
|
|
get { waitForBackupUploadSteadyStateProgressListenerReceivedInvocationsLock.withLock { waitForBackupUploadSteadyStateProgressListenerUnderlyingReceivedInvocations } }
|
|
set { waitForBackupUploadSteadyStateProgressListenerReceivedInvocationsLock.withLock { waitForBackupUploadSteadyStateProgressListenerUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var waitForBackupUploadSteadyStateProgressListenerClosure: ((BackupSteadyStateListener?) async throws -> Void)?
|
|
|
|
open override func waitForBackupUploadSteadyState(progressListener: BackupSteadyStateListener?) async throws {
|
|
if let error = waitForBackupUploadSteadyStateProgressListenerThrowableError {
|
|
throw error
|
|
}
|
|
waitForBackupUploadSteadyStateProgressListenerCallsCountLock.withLock { waitForBackupUploadSteadyStateProgressListenerUnderlyingCallsCount += 1 }
|
|
waitForBackupUploadSteadyStateProgressListenerReceivedProgressListener = progressListener
|
|
waitForBackupUploadSteadyStateProgressListenerReceivedInvocationsLock.withLock { waitForBackupUploadSteadyStateProgressListenerUnderlyingReceivedInvocations.append(progressListener) }
|
|
try await waitForBackupUploadSteadyStateProgressListenerClosure?(progressListener)
|
|
}
|
|
|
|
//MARK: - waitForE2eeInitializationTasks
|
|
|
|
private let waitForE2eeInitializationTasksCallsCountLock = NSLock()
|
|
private var waitForE2eeInitializationTasksUnderlyingCallsCount = 0
|
|
open var waitForE2eeInitializationTasksCallsCount: Int {
|
|
get { waitForE2eeInitializationTasksCallsCountLock.withLock { waitForE2eeInitializationTasksUnderlyingCallsCount } }
|
|
set { waitForE2eeInitializationTasksCallsCountLock.withLock { waitForE2eeInitializationTasksUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var waitForE2eeInitializationTasksCalled: Bool {
|
|
return waitForE2eeInitializationTasksCallsCount > 0
|
|
}
|
|
open var waitForE2eeInitializationTasksClosure: (() async -> Void)?
|
|
|
|
open override func waitForE2eeInitializationTasks() async {
|
|
waitForE2eeInitializationTasksCallsCountLock.withLock { waitForE2eeInitializationTasksUnderlyingCallsCount += 1 }
|
|
await waitForE2eeInitializationTasksClosure?()
|
|
}
|
|
}
|
|
open class GrantLoginWithQrCodeHandlerSDKMock: MatrixRustSDK.GrantLoginWithQrCodeHandler, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
|
|
//MARK: - generate
|
|
|
|
open var generateProgressListenerThrowableError: Error?
|
|
private let generateProgressListenerCallsCountLock = NSLock()
|
|
private var generateProgressListenerUnderlyingCallsCount = 0
|
|
open var generateProgressListenerCallsCount: Int {
|
|
get { generateProgressListenerCallsCountLock.withLock { generateProgressListenerUnderlyingCallsCount } }
|
|
set { generateProgressListenerCallsCountLock.withLock { generateProgressListenerUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var generateProgressListenerCalled: Bool {
|
|
return generateProgressListenerCallsCount > 0
|
|
}
|
|
private let generateProgressListenerReceivedProgressListenerLock = NSLock()
|
|
private var generateProgressListenerUnderlyingReceivedProgressListener: GrantGeneratedQrLoginProgressListener?
|
|
open var generateProgressListenerReceivedProgressListener: GrantGeneratedQrLoginProgressListener? {
|
|
get { generateProgressListenerReceivedProgressListenerLock.withLock { generateProgressListenerUnderlyingReceivedProgressListener } }
|
|
set { generateProgressListenerReceivedProgressListenerLock.withLock { generateProgressListenerUnderlyingReceivedProgressListener = newValue } }
|
|
}
|
|
private let generateProgressListenerReceivedInvocationsLock = NSLock()
|
|
private var generateProgressListenerUnderlyingReceivedInvocations: [GrantGeneratedQrLoginProgressListener] = []
|
|
open var generateProgressListenerReceivedInvocations: [GrantGeneratedQrLoginProgressListener] {
|
|
get { generateProgressListenerReceivedInvocationsLock.withLock { generateProgressListenerUnderlyingReceivedInvocations } }
|
|
set { generateProgressListenerReceivedInvocationsLock.withLock { generateProgressListenerUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var generateProgressListenerClosure: ((GrantGeneratedQrLoginProgressListener) async throws -> Void)?
|
|
|
|
open override func generate(progressListener: GrantGeneratedQrLoginProgressListener) async throws {
|
|
if let error = generateProgressListenerThrowableError {
|
|
throw error
|
|
}
|
|
generateProgressListenerCallsCountLock.withLock { generateProgressListenerUnderlyingCallsCount += 1 }
|
|
generateProgressListenerReceivedProgressListener = progressListener
|
|
generateProgressListenerReceivedInvocationsLock.withLock { generateProgressListenerUnderlyingReceivedInvocations.append(progressListener) }
|
|
try await generateProgressListenerClosure?(progressListener)
|
|
}
|
|
|
|
//MARK: - scan
|
|
|
|
open var scanQrCodeDataProgressListenerThrowableError: Error?
|
|
private let scanQrCodeDataProgressListenerCallsCountLock = NSLock()
|
|
private var scanQrCodeDataProgressListenerUnderlyingCallsCount = 0
|
|
open var scanQrCodeDataProgressListenerCallsCount: Int {
|
|
get { scanQrCodeDataProgressListenerCallsCountLock.withLock { scanQrCodeDataProgressListenerUnderlyingCallsCount } }
|
|
set { scanQrCodeDataProgressListenerCallsCountLock.withLock { scanQrCodeDataProgressListenerUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var scanQrCodeDataProgressListenerCalled: Bool {
|
|
return scanQrCodeDataProgressListenerCallsCount > 0
|
|
}
|
|
private let scanQrCodeDataProgressListenerReceivedArgumentsLock = NSLock()
|
|
private var scanQrCodeDataProgressListenerUnderlyingReceivedArguments: (qrCodeData: QrCodeData, progressListener: GrantQrLoginProgressListener)?
|
|
open var scanQrCodeDataProgressListenerReceivedArguments: (qrCodeData: QrCodeData, progressListener: GrantQrLoginProgressListener)? {
|
|
get { scanQrCodeDataProgressListenerReceivedArgumentsLock.withLock { scanQrCodeDataProgressListenerUnderlyingReceivedArguments } }
|
|
set { scanQrCodeDataProgressListenerReceivedArgumentsLock.withLock { scanQrCodeDataProgressListenerUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let scanQrCodeDataProgressListenerReceivedInvocationsLock = NSLock()
|
|
private var scanQrCodeDataProgressListenerUnderlyingReceivedInvocations: [(qrCodeData: QrCodeData, progressListener: GrantQrLoginProgressListener)] = []
|
|
open var scanQrCodeDataProgressListenerReceivedInvocations: [(qrCodeData: QrCodeData, progressListener: GrantQrLoginProgressListener)] {
|
|
get { scanQrCodeDataProgressListenerReceivedInvocationsLock.withLock { scanQrCodeDataProgressListenerUnderlyingReceivedInvocations } }
|
|
set { scanQrCodeDataProgressListenerReceivedInvocationsLock.withLock { scanQrCodeDataProgressListenerUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var scanQrCodeDataProgressListenerClosure: ((QrCodeData, GrantQrLoginProgressListener) async throws -> Void)?
|
|
|
|
open override func scan(qrCodeData: QrCodeData, progressListener: GrantQrLoginProgressListener) async throws {
|
|
if let error = scanQrCodeDataProgressListenerThrowableError {
|
|
throw error
|
|
}
|
|
scanQrCodeDataProgressListenerCallsCountLock.withLock { scanQrCodeDataProgressListenerUnderlyingCallsCount += 1 }
|
|
scanQrCodeDataProgressListenerReceivedArguments = (qrCodeData: qrCodeData, progressListener: progressListener)
|
|
scanQrCodeDataProgressListenerReceivedInvocationsLock.withLock { scanQrCodeDataProgressListenerUnderlyingReceivedInvocations.append((qrCodeData: qrCodeData, progressListener: progressListener)) }
|
|
try await scanQrCodeDataProgressListenerClosure?(qrCodeData, progressListener)
|
|
}
|
|
}
|
|
open class HomeserverCapabilitiesSDKMock: MatrixRustSDK.HomeserverCapabilities, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
|
|
//MARK: - canChangeAvatar
|
|
|
|
open var canChangeAvatarThrowableError: Error?
|
|
private let canChangeAvatarCallsCountLock = NSLock()
|
|
private var canChangeAvatarUnderlyingCallsCount = 0
|
|
open var canChangeAvatarCallsCount: Int {
|
|
get { canChangeAvatarCallsCountLock.withLock { canChangeAvatarUnderlyingCallsCount } }
|
|
set { canChangeAvatarCallsCountLock.withLock { canChangeAvatarUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var canChangeAvatarCalled: Bool {
|
|
return canChangeAvatarCallsCount > 0
|
|
}
|
|
|
|
private let canChangeAvatarReturnValueLock = NSLock()
|
|
open var canChangeAvatarUnderlyingReturnValue: Bool!
|
|
open var canChangeAvatarReturnValue: Bool! {
|
|
get { canChangeAvatarReturnValueLock.withLock { canChangeAvatarUnderlyingReturnValue } }
|
|
set { canChangeAvatarReturnValueLock.withLock { canChangeAvatarUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var canChangeAvatarClosure: (() async throws -> Bool)?
|
|
|
|
open override func canChangeAvatar() async throws -> Bool {
|
|
if let error = canChangeAvatarThrowableError {
|
|
throw error
|
|
}
|
|
canChangeAvatarCallsCountLock.withLock { canChangeAvatarUnderlyingCallsCount += 1 }
|
|
if let canChangeAvatarClosure = canChangeAvatarClosure {
|
|
return try await canChangeAvatarClosure()
|
|
} else {
|
|
return canChangeAvatarReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - canChangeDisplayname
|
|
|
|
open var canChangeDisplaynameThrowableError: Error?
|
|
private let canChangeDisplaynameCallsCountLock = NSLock()
|
|
private var canChangeDisplaynameUnderlyingCallsCount = 0
|
|
open var canChangeDisplaynameCallsCount: Int {
|
|
get { canChangeDisplaynameCallsCountLock.withLock { canChangeDisplaynameUnderlyingCallsCount } }
|
|
set { canChangeDisplaynameCallsCountLock.withLock { canChangeDisplaynameUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var canChangeDisplaynameCalled: Bool {
|
|
return canChangeDisplaynameCallsCount > 0
|
|
}
|
|
|
|
private let canChangeDisplaynameReturnValueLock = NSLock()
|
|
open var canChangeDisplaynameUnderlyingReturnValue: Bool!
|
|
open var canChangeDisplaynameReturnValue: Bool! {
|
|
get { canChangeDisplaynameReturnValueLock.withLock { canChangeDisplaynameUnderlyingReturnValue } }
|
|
set { canChangeDisplaynameReturnValueLock.withLock { canChangeDisplaynameUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var canChangeDisplaynameClosure: (() async throws -> Bool)?
|
|
|
|
open override func canChangeDisplayname() async throws -> Bool {
|
|
if let error = canChangeDisplaynameThrowableError {
|
|
throw error
|
|
}
|
|
canChangeDisplaynameCallsCountLock.withLock { canChangeDisplaynameUnderlyingCallsCount += 1 }
|
|
if let canChangeDisplaynameClosure = canChangeDisplaynameClosure {
|
|
return try await canChangeDisplaynameClosure()
|
|
} else {
|
|
return canChangeDisplaynameReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - canChangePassword
|
|
|
|
open var canChangePasswordThrowableError: Error?
|
|
private let canChangePasswordCallsCountLock = NSLock()
|
|
private var canChangePasswordUnderlyingCallsCount = 0
|
|
open var canChangePasswordCallsCount: Int {
|
|
get { canChangePasswordCallsCountLock.withLock { canChangePasswordUnderlyingCallsCount } }
|
|
set { canChangePasswordCallsCountLock.withLock { canChangePasswordUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var canChangePasswordCalled: Bool {
|
|
return canChangePasswordCallsCount > 0
|
|
}
|
|
|
|
private let canChangePasswordReturnValueLock = NSLock()
|
|
open var canChangePasswordUnderlyingReturnValue: Bool!
|
|
open var canChangePasswordReturnValue: Bool! {
|
|
get { canChangePasswordReturnValueLock.withLock { canChangePasswordUnderlyingReturnValue } }
|
|
set { canChangePasswordReturnValueLock.withLock { canChangePasswordUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var canChangePasswordClosure: (() async throws -> Bool)?
|
|
|
|
open override func canChangePassword() async throws -> Bool {
|
|
if let error = canChangePasswordThrowableError {
|
|
throw error
|
|
}
|
|
canChangePasswordCallsCountLock.withLock { canChangePasswordUnderlyingCallsCount += 1 }
|
|
if let canChangePasswordClosure = canChangePasswordClosure {
|
|
return try await canChangePasswordClosure()
|
|
} else {
|
|
return canChangePasswordReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - canChangeThirdpartyIds
|
|
|
|
open var canChangeThirdpartyIdsThrowableError: Error?
|
|
private let canChangeThirdpartyIdsCallsCountLock = NSLock()
|
|
private var canChangeThirdpartyIdsUnderlyingCallsCount = 0
|
|
open var canChangeThirdpartyIdsCallsCount: Int {
|
|
get { canChangeThirdpartyIdsCallsCountLock.withLock { canChangeThirdpartyIdsUnderlyingCallsCount } }
|
|
set { canChangeThirdpartyIdsCallsCountLock.withLock { canChangeThirdpartyIdsUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var canChangeThirdpartyIdsCalled: Bool {
|
|
return canChangeThirdpartyIdsCallsCount > 0
|
|
}
|
|
|
|
private let canChangeThirdpartyIdsReturnValueLock = NSLock()
|
|
open var canChangeThirdpartyIdsUnderlyingReturnValue: Bool!
|
|
open var canChangeThirdpartyIdsReturnValue: Bool! {
|
|
get { canChangeThirdpartyIdsReturnValueLock.withLock { canChangeThirdpartyIdsUnderlyingReturnValue } }
|
|
set { canChangeThirdpartyIdsReturnValueLock.withLock { canChangeThirdpartyIdsUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var canChangeThirdpartyIdsClosure: (() async throws -> Bool)?
|
|
|
|
open override func canChangeThirdpartyIds() async throws -> Bool {
|
|
if let error = canChangeThirdpartyIdsThrowableError {
|
|
throw error
|
|
}
|
|
canChangeThirdpartyIdsCallsCountLock.withLock { canChangeThirdpartyIdsUnderlyingCallsCount += 1 }
|
|
if let canChangeThirdpartyIdsClosure = canChangeThirdpartyIdsClosure {
|
|
return try await canChangeThirdpartyIdsClosure()
|
|
} else {
|
|
return canChangeThirdpartyIdsReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - canGetLoginToken
|
|
|
|
open var canGetLoginTokenThrowableError: Error?
|
|
private let canGetLoginTokenCallsCountLock = NSLock()
|
|
private var canGetLoginTokenUnderlyingCallsCount = 0
|
|
open var canGetLoginTokenCallsCount: Int {
|
|
get { canGetLoginTokenCallsCountLock.withLock { canGetLoginTokenUnderlyingCallsCount } }
|
|
set { canGetLoginTokenCallsCountLock.withLock { canGetLoginTokenUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var canGetLoginTokenCalled: Bool {
|
|
return canGetLoginTokenCallsCount > 0
|
|
}
|
|
|
|
private let canGetLoginTokenReturnValueLock = NSLock()
|
|
open var canGetLoginTokenUnderlyingReturnValue: Bool!
|
|
open var canGetLoginTokenReturnValue: Bool! {
|
|
get { canGetLoginTokenReturnValueLock.withLock { canGetLoginTokenUnderlyingReturnValue } }
|
|
set { canGetLoginTokenReturnValueLock.withLock { canGetLoginTokenUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var canGetLoginTokenClosure: (() async throws -> Bool)?
|
|
|
|
open override func canGetLoginToken() async throws -> Bool {
|
|
if let error = canGetLoginTokenThrowableError {
|
|
throw error
|
|
}
|
|
canGetLoginTokenCallsCountLock.withLock { canGetLoginTokenUnderlyingCallsCount += 1 }
|
|
if let canGetLoginTokenClosure = canGetLoginTokenClosure {
|
|
return try await canGetLoginTokenClosure()
|
|
} else {
|
|
return canGetLoginTokenReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - extendedProfileFields
|
|
|
|
open var extendedProfileFieldsThrowableError: Error?
|
|
private let extendedProfileFieldsCallsCountLock = NSLock()
|
|
private var extendedProfileFieldsUnderlyingCallsCount = 0
|
|
open var extendedProfileFieldsCallsCount: Int {
|
|
get { extendedProfileFieldsCallsCountLock.withLock { extendedProfileFieldsUnderlyingCallsCount } }
|
|
set { extendedProfileFieldsCallsCountLock.withLock { extendedProfileFieldsUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var extendedProfileFieldsCalled: Bool {
|
|
return extendedProfileFieldsCallsCount > 0
|
|
}
|
|
|
|
private let extendedProfileFieldsReturnValueLock = NSLock()
|
|
open var extendedProfileFieldsUnderlyingReturnValue: ExtendedProfileFields!
|
|
open var extendedProfileFieldsReturnValue: ExtendedProfileFields! {
|
|
get { extendedProfileFieldsReturnValueLock.withLock { extendedProfileFieldsUnderlyingReturnValue } }
|
|
set { extendedProfileFieldsReturnValueLock.withLock { extendedProfileFieldsUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var extendedProfileFieldsClosure: (() async throws -> ExtendedProfileFields)?
|
|
|
|
open override func extendedProfileFields() async throws -> ExtendedProfileFields {
|
|
if let error = extendedProfileFieldsThrowableError {
|
|
throw error
|
|
}
|
|
extendedProfileFieldsCallsCountLock.withLock { extendedProfileFieldsUnderlyingCallsCount += 1 }
|
|
if let extendedProfileFieldsClosure = extendedProfileFieldsClosure {
|
|
return try await extendedProfileFieldsClosure()
|
|
} else {
|
|
return extendedProfileFieldsReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - forgetsRoomWhenLeaving
|
|
|
|
open var forgetsRoomWhenLeavingThrowableError: Error?
|
|
private let forgetsRoomWhenLeavingCallsCountLock = NSLock()
|
|
private var forgetsRoomWhenLeavingUnderlyingCallsCount = 0
|
|
open var forgetsRoomWhenLeavingCallsCount: Int {
|
|
get { forgetsRoomWhenLeavingCallsCountLock.withLock { forgetsRoomWhenLeavingUnderlyingCallsCount } }
|
|
set { forgetsRoomWhenLeavingCallsCountLock.withLock { forgetsRoomWhenLeavingUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var forgetsRoomWhenLeavingCalled: Bool {
|
|
return forgetsRoomWhenLeavingCallsCount > 0
|
|
}
|
|
|
|
private let forgetsRoomWhenLeavingReturnValueLock = NSLock()
|
|
open var forgetsRoomWhenLeavingUnderlyingReturnValue: Bool!
|
|
open var forgetsRoomWhenLeavingReturnValue: Bool! {
|
|
get { forgetsRoomWhenLeavingReturnValueLock.withLock { forgetsRoomWhenLeavingUnderlyingReturnValue } }
|
|
set { forgetsRoomWhenLeavingReturnValueLock.withLock { forgetsRoomWhenLeavingUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var forgetsRoomWhenLeavingClosure: (() async throws -> Bool)?
|
|
|
|
open override func forgetsRoomWhenLeaving() async throws -> Bool {
|
|
if let error = forgetsRoomWhenLeavingThrowableError {
|
|
throw error
|
|
}
|
|
forgetsRoomWhenLeavingCallsCountLock.withLock { forgetsRoomWhenLeavingUnderlyingCallsCount += 1 }
|
|
if let forgetsRoomWhenLeavingClosure = forgetsRoomWhenLeavingClosure {
|
|
return try await forgetsRoomWhenLeavingClosure()
|
|
} else {
|
|
return forgetsRoomWhenLeavingReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - refresh
|
|
|
|
open var refreshThrowableError: Error?
|
|
private let refreshCallsCountLock = NSLock()
|
|
private var refreshUnderlyingCallsCount = 0
|
|
open var refreshCallsCount: Int {
|
|
get { refreshCallsCountLock.withLock { refreshUnderlyingCallsCount } }
|
|
set { refreshCallsCountLock.withLock { refreshUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var refreshCalled: Bool {
|
|
return refreshCallsCount > 0
|
|
}
|
|
open var refreshClosure: (() async throws -> Void)?
|
|
|
|
open override func refresh() async throws {
|
|
if let error = refreshThrowableError {
|
|
throw error
|
|
}
|
|
refreshCallsCountLock.withLock { refreshUnderlyingCallsCount += 1 }
|
|
try await refreshClosure?()
|
|
}
|
|
}
|
|
open class HomeserverLoginDetailsSDKMock: MatrixRustSDK.HomeserverLoginDetails, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
|
|
//MARK: - slidingSyncVersion
|
|
|
|
private let slidingSyncVersionCallsCountLock = NSLock()
|
|
private var slidingSyncVersionUnderlyingCallsCount = 0
|
|
open var slidingSyncVersionCallsCount: Int {
|
|
get { slidingSyncVersionCallsCountLock.withLock { slidingSyncVersionUnderlyingCallsCount } }
|
|
set { slidingSyncVersionCallsCountLock.withLock { slidingSyncVersionUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var slidingSyncVersionCalled: Bool {
|
|
return slidingSyncVersionCallsCount > 0
|
|
}
|
|
|
|
private let slidingSyncVersionReturnValueLock = NSLock()
|
|
open var slidingSyncVersionUnderlyingReturnValue: SlidingSyncVersion!
|
|
open var slidingSyncVersionReturnValue: SlidingSyncVersion! {
|
|
get { slidingSyncVersionReturnValueLock.withLock { slidingSyncVersionUnderlyingReturnValue } }
|
|
set { slidingSyncVersionReturnValueLock.withLock { slidingSyncVersionUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var slidingSyncVersionClosure: (() -> SlidingSyncVersion)?
|
|
|
|
open override func slidingSyncVersion() -> SlidingSyncVersion {
|
|
slidingSyncVersionCallsCountLock.withLock { slidingSyncVersionUnderlyingCallsCount += 1 }
|
|
if let slidingSyncVersionClosure = slidingSyncVersionClosure {
|
|
return slidingSyncVersionClosure()
|
|
} else {
|
|
return slidingSyncVersionReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - supportedOauthPrompts
|
|
|
|
private let supportedOauthPromptsCallsCountLock = NSLock()
|
|
private var supportedOauthPromptsUnderlyingCallsCount = 0
|
|
open var supportedOauthPromptsCallsCount: Int {
|
|
get { supportedOauthPromptsCallsCountLock.withLock { supportedOauthPromptsUnderlyingCallsCount } }
|
|
set { supportedOauthPromptsCallsCountLock.withLock { supportedOauthPromptsUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var supportedOauthPromptsCalled: Bool {
|
|
return supportedOauthPromptsCallsCount > 0
|
|
}
|
|
|
|
private let supportedOauthPromptsReturnValueLock = NSLock()
|
|
open var supportedOauthPromptsUnderlyingReturnValue: [OAuthPrompt]!
|
|
open var supportedOauthPromptsReturnValue: [OAuthPrompt]! {
|
|
get { supportedOauthPromptsReturnValueLock.withLock { supportedOauthPromptsUnderlyingReturnValue } }
|
|
set { supportedOauthPromptsReturnValueLock.withLock { supportedOauthPromptsUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var supportedOauthPromptsClosure: (() -> [OAuthPrompt])?
|
|
|
|
open override func supportedOauthPrompts() -> [OAuthPrompt] {
|
|
supportedOauthPromptsCallsCountLock.withLock { supportedOauthPromptsUnderlyingCallsCount += 1 }
|
|
if let supportedOauthPromptsClosure = supportedOauthPromptsClosure {
|
|
return supportedOauthPromptsClosure()
|
|
} else {
|
|
return supportedOauthPromptsReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - supportsOauthLogin
|
|
|
|
private let supportsOauthLoginCallsCountLock = NSLock()
|
|
private var supportsOauthLoginUnderlyingCallsCount = 0
|
|
open var supportsOauthLoginCallsCount: Int {
|
|
get { supportsOauthLoginCallsCountLock.withLock { supportsOauthLoginUnderlyingCallsCount } }
|
|
set { supportsOauthLoginCallsCountLock.withLock { supportsOauthLoginUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var supportsOauthLoginCalled: Bool {
|
|
return supportsOauthLoginCallsCount > 0
|
|
}
|
|
|
|
private let supportsOauthLoginReturnValueLock = NSLock()
|
|
open var supportsOauthLoginUnderlyingReturnValue: Bool!
|
|
open var supportsOauthLoginReturnValue: Bool! {
|
|
get { supportsOauthLoginReturnValueLock.withLock { supportsOauthLoginUnderlyingReturnValue } }
|
|
set { supportsOauthLoginReturnValueLock.withLock { supportsOauthLoginUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var supportsOauthLoginClosure: (() -> Bool)?
|
|
|
|
open override func supportsOauthLogin() -> Bool {
|
|
supportsOauthLoginCallsCountLock.withLock { supportsOauthLoginUnderlyingCallsCount += 1 }
|
|
if let supportsOauthLoginClosure = supportsOauthLoginClosure {
|
|
return supportsOauthLoginClosure()
|
|
} else {
|
|
return supportsOauthLoginReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - supportsPasswordLogin
|
|
|
|
private let supportsPasswordLoginCallsCountLock = NSLock()
|
|
private var supportsPasswordLoginUnderlyingCallsCount = 0
|
|
open var supportsPasswordLoginCallsCount: Int {
|
|
get { supportsPasswordLoginCallsCountLock.withLock { supportsPasswordLoginUnderlyingCallsCount } }
|
|
set { supportsPasswordLoginCallsCountLock.withLock { supportsPasswordLoginUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var supportsPasswordLoginCalled: Bool {
|
|
return supportsPasswordLoginCallsCount > 0
|
|
}
|
|
|
|
private let supportsPasswordLoginReturnValueLock = NSLock()
|
|
open var supportsPasswordLoginUnderlyingReturnValue: Bool!
|
|
open var supportsPasswordLoginReturnValue: Bool! {
|
|
get { supportsPasswordLoginReturnValueLock.withLock { supportsPasswordLoginUnderlyingReturnValue } }
|
|
set { supportsPasswordLoginReturnValueLock.withLock { supportsPasswordLoginUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var supportsPasswordLoginClosure: (() -> Bool)?
|
|
|
|
open override func supportsPasswordLogin() -> Bool {
|
|
supportsPasswordLoginCallsCountLock.withLock { supportsPasswordLoginUnderlyingCallsCount += 1 }
|
|
if let supportsPasswordLoginClosure = supportsPasswordLoginClosure {
|
|
return supportsPasswordLoginClosure()
|
|
} else {
|
|
return supportsPasswordLoginReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - supportsSsoLogin
|
|
|
|
private let supportsSsoLoginCallsCountLock = NSLock()
|
|
private var supportsSsoLoginUnderlyingCallsCount = 0
|
|
open var supportsSsoLoginCallsCount: Int {
|
|
get { supportsSsoLoginCallsCountLock.withLock { supportsSsoLoginUnderlyingCallsCount } }
|
|
set { supportsSsoLoginCallsCountLock.withLock { supportsSsoLoginUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var supportsSsoLoginCalled: Bool {
|
|
return supportsSsoLoginCallsCount > 0
|
|
}
|
|
|
|
private let supportsSsoLoginReturnValueLock = NSLock()
|
|
open var supportsSsoLoginUnderlyingReturnValue: Bool!
|
|
open var supportsSsoLoginReturnValue: Bool! {
|
|
get { supportsSsoLoginReturnValueLock.withLock { supportsSsoLoginUnderlyingReturnValue } }
|
|
set { supportsSsoLoginReturnValueLock.withLock { supportsSsoLoginUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var supportsSsoLoginClosure: (() -> Bool)?
|
|
|
|
open override func supportsSsoLogin() -> Bool {
|
|
supportsSsoLoginCallsCountLock.withLock { supportsSsoLoginUnderlyingCallsCount += 1 }
|
|
if let supportsSsoLoginClosure = supportsSsoLoginClosure {
|
|
return supportsSsoLoginClosure()
|
|
} else {
|
|
return supportsSsoLoginReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - url
|
|
|
|
private let urlCallsCountLock = NSLock()
|
|
private var urlUnderlyingCallsCount = 0
|
|
open var urlCallsCount: Int {
|
|
get { urlCallsCountLock.withLock { urlUnderlyingCallsCount } }
|
|
set { urlCallsCountLock.withLock { urlUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var urlCalled: Bool {
|
|
return urlCallsCount > 0
|
|
}
|
|
|
|
private let urlReturnValueLock = NSLock()
|
|
open var urlUnderlyingReturnValue: String!
|
|
open var urlReturnValue: String! {
|
|
get { urlReturnValueLock.withLock { urlUnderlyingReturnValue } }
|
|
set { urlReturnValueLock.withLock { urlUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var urlClosure: (() -> String)?
|
|
|
|
open override func url() -> String {
|
|
urlCallsCountLock.withLock { urlUnderlyingCallsCount += 1 }
|
|
if let urlClosure = urlClosure {
|
|
return urlClosure()
|
|
} else {
|
|
return urlReturnValue
|
|
}
|
|
}
|
|
}
|
|
open class IdentityResetHandleSDKMock: MatrixRustSDK.IdentityResetHandle, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
|
|
//MARK: - authType
|
|
|
|
private let authTypeCallsCountLock = NSLock()
|
|
private var authTypeUnderlyingCallsCount = 0
|
|
open var authTypeCallsCount: Int {
|
|
get { authTypeCallsCountLock.withLock { authTypeUnderlyingCallsCount } }
|
|
set { authTypeCallsCountLock.withLock { authTypeUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var authTypeCalled: Bool {
|
|
return authTypeCallsCount > 0
|
|
}
|
|
|
|
private let authTypeReturnValueLock = NSLock()
|
|
open var authTypeUnderlyingReturnValue: CrossSigningResetAuthType!
|
|
open var authTypeReturnValue: CrossSigningResetAuthType! {
|
|
get { authTypeReturnValueLock.withLock { authTypeUnderlyingReturnValue } }
|
|
set { authTypeReturnValueLock.withLock { authTypeUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var authTypeClosure: (() -> CrossSigningResetAuthType)?
|
|
|
|
open override func authType() -> CrossSigningResetAuthType {
|
|
authTypeCallsCountLock.withLock { authTypeUnderlyingCallsCount += 1 }
|
|
if let authTypeClosure = authTypeClosure {
|
|
return authTypeClosure()
|
|
} else {
|
|
return authTypeReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - cancel
|
|
|
|
private let cancelCallsCountLock = NSLock()
|
|
private var cancelUnderlyingCallsCount = 0
|
|
open var cancelCallsCount: Int {
|
|
get { cancelCallsCountLock.withLock { cancelUnderlyingCallsCount } }
|
|
set { cancelCallsCountLock.withLock { cancelUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var cancelCalled: Bool {
|
|
return cancelCallsCount > 0
|
|
}
|
|
open var cancelClosure: (() async -> Void)?
|
|
|
|
open override func cancel() async {
|
|
cancelCallsCountLock.withLock { cancelUnderlyingCallsCount += 1 }
|
|
await cancelClosure?()
|
|
}
|
|
|
|
//MARK: - reset
|
|
|
|
open var resetAuthThrowableError: Error?
|
|
private let resetAuthCallsCountLock = NSLock()
|
|
private var resetAuthUnderlyingCallsCount = 0
|
|
open var resetAuthCallsCount: Int {
|
|
get { resetAuthCallsCountLock.withLock { resetAuthUnderlyingCallsCount } }
|
|
set { resetAuthCallsCountLock.withLock { resetAuthUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var resetAuthCalled: Bool {
|
|
return resetAuthCallsCount > 0
|
|
}
|
|
private let resetAuthReceivedAuthLock = NSLock()
|
|
private var resetAuthUnderlyingReceivedAuth: AuthData?
|
|
open var resetAuthReceivedAuth: AuthData? {
|
|
get { resetAuthReceivedAuthLock.withLock { resetAuthUnderlyingReceivedAuth } }
|
|
set { resetAuthReceivedAuthLock.withLock { resetAuthUnderlyingReceivedAuth = newValue } }
|
|
}
|
|
private let resetAuthReceivedInvocationsLock = NSLock()
|
|
private var resetAuthUnderlyingReceivedInvocations: [AuthData?] = []
|
|
open var resetAuthReceivedInvocations: [AuthData?] {
|
|
get { resetAuthReceivedInvocationsLock.withLock { resetAuthUnderlyingReceivedInvocations } }
|
|
set { resetAuthReceivedInvocationsLock.withLock { resetAuthUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var resetAuthClosure: ((AuthData?) async throws -> Void)?
|
|
|
|
open override func reset(auth: AuthData?) async throws {
|
|
if let error = resetAuthThrowableError {
|
|
throw error
|
|
}
|
|
resetAuthCallsCountLock.withLock { resetAuthUnderlyingCallsCount += 1 }
|
|
resetAuthReceivedAuth = auth
|
|
resetAuthReceivedInvocationsLock.withLock { resetAuthUnderlyingReceivedInvocations.append(auth) }
|
|
try await resetAuthClosure?(auth)
|
|
}
|
|
}
|
|
open class InReplyToDetailsSDKMock: MatrixRustSDK.InReplyToDetails, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
|
|
//MARK: - event
|
|
|
|
private let eventCallsCountLock = NSLock()
|
|
private var eventUnderlyingCallsCount = 0
|
|
open var eventCallsCount: Int {
|
|
get { eventCallsCountLock.withLock { eventUnderlyingCallsCount } }
|
|
set { eventCallsCountLock.withLock { eventUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var eventCalled: Bool {
|
|
return eventCallsCount > 0
|
|
}
|
|
|
|
private let eventReturnValueLock = NSLock()
|
|
open var eventUnderlyingReturnValue: EmbeddedEventDetails!
|
|
open var eventReturnValue: EmbeddedEventDetails! {
|
|
get { eventReturnValueLock.withLock { eventUnderlyingReturnValue } }
|
|
set { eventReturnValueLock.withLock { eventUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var eventClosure: (() -> EmbeddedEventDetails)?
|
|
|
|
open override func event() -> EmbeddedEventDetails {
|
|
eventCallsCountLock.withLock { eventUnderlyingCallsCount += 1 }
|
|
if let eventClosure = eventClosure {
|
|
return eventClosure()
|
|
} else {
|
|
return eventReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - eventId
|
|
|
|
private let eventIdCallsCountLock = NSLock()
|
|
private var eventIdUnderlyingCallsCount = 0
|
|
open var eventIdCallsCount: Int {
|
|
get { eventIdCallsCountLock.withLock { eventIdUnderlyingCallsCount } }
|
|
set { eventIdCallsCountLock.withLock { eventIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var eventIdCalled: Bool {
|
|
return eventIdCallsCount > 0
|
|
}
|
|
|
|
private let eventIdReturnValueLock = NSLock()
|
|
open var eventIdUnderlyingReturnValue: String!
|
|
open var eventIdReturnValue: String! {
|
|
get { eventIdReturnValueLock.withLock { eventIdUnderlyingReturnValue } }
|
|
set { eventIdReturnValueLock.withLock { eventIdUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var eventIdClosure: (() -> String)?
|
|
|
|
open override func eventId() -> String {
|
|
eventIdCallsCountLock.withLock { eventIdUnderlyingCallsCount += 1 }
|
|
if let eventIdClosure = eventIdClosure {
|
|
return eventIdClosure()
|
|
} else {
|
|
return eventIdReturnValue
|
|
}
|
|
}
|
|
}
|
|
open class KnockRequestActionsSDKMock: MatrixRustSDK.KnockRequestActions, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
|
|
//MARK: - accept
|
|
|
|
open var acceptThrowableError: Error?
|
|
private let acceptCallsCountLock = NSLock()
|
|
private var acceptUnderlyingCallsCount = 0
|
|
open var acceptCallsCount: Int {
|
|
get { acceptCallsCountLock.withLock { acceptUnderlyingCallsCount } }
|
|
set { acceptCallsCountLock.withLock { acceptUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var acceptCalled: Bool {
|
|
return acceptCallsCount > 0
|
|
}
|
|
open var acceptClosure: (() async throws -> Void)?
|
|
|
|
open override func accept() async throws {
|
|
if let error = acceptThrowableError {
|
|
throw error
|
|
}
|
|
acceptCallsCountLock.withLock { acceptUnderlyingCallsCount += 1 }
|
|
try await acceptClosure?()
|
|
}
|
|
|
|
//MARK: - decline
|
|
|
|
open var declineReasonThrowableError: Error?
|
|
private let declineReasonCallsCountLock = NSLock()
|
|
private var declineReasonUnderlyingCallsCount = 0
|
|
open var declineReasonCallsCount: Int {
|
|
get { declineReasonCallsCountLock.withLock { declineReasonUnderlyingCallsCount } }
|
|
set { declineReasonCallsCountLock.withLock { declineReasonUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var declineReasonCalled: Bool {
|
|
return declineReasonCallsCount > 0
|
|
}
|
|
private let declineReasonReceivedReasonLock = NSLock()
|
|
private var declineReasonUnderlyingReceivedReason: String?
|
|
open var declineReasonReceivedReason: String? {
|
|
get { declineReasonReceivedReasonLock.withLock { declineReasonUnderlyingReceivedReason } }
|
|
set { declineReasonReceivedReasonLock.withLock { declineReasonUnderlyingReceivedReason = newValue } }
|
|
}
|
|
private let declineReasonReceivedInvocationsLock = NSLock()
|
|
private var declineReasonUnderlyingReceivedInvocations: [String?] = []
|
|
open var declineReasonReceivedInvocations: [String?] {
|
|
get { declineReasonReceivedInvocationsLock.withLock { declineReasonUnderlyingReceivedInvocations } }
|
|
set { declineReasonReceivedInvocationsLock.withLock { declineReasonUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var declineReasonClosure: ((String?) async throws -> Void)?
|
|
|
|
open override func decline(reason: String?) async throws {
|
|
if let error = declineReasonThrowableError {
|
|
throw error
|
|
}
|
|
declineReasonCallsCountLock.withLock { declineReasonUnderlyingCallsCount += 1 }
|
|
declineReasonReceivedReason = reason
|
|
declineReasonReceivedInvocationsLock.withLock { declineReasonUnderlyingReceivedInvocations.append(reason) }
|
|
try await declineReasonClosure?(reason)
|
|
}
|
|
|
|
//MARK: - declineAndBan
|
|
|
|
open var declineAndBanReasonThrowableError: Error?
|
|
private let declineAndBanReasonCallsCountLock = NSLock()
|
|
private var declineAndBanReasonUnderlyingCallsCount = 0
|
|
open var declineAndBanReasonCallsCount: Int {
|
|
get { declineAndBanReasonCallsCountLock.withLock { declineAndBanReasonUnderlyingCallsCount } }
|
|
set { declineAndBanReasonCallsCountLock.withLock { declineAndBanReasonUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var declineAndBanReasonCalled: Bool {
|
|
return declineAndBanReasonCallsCount > 0
|
|
}
|
|
private let declineAndBanReasonReceivedReasonLock = NSLock()
|
|
private var declineAndBanReasonUnderlyingReceivedReason: String?
|
|
open var declineAndBanReasonReceivedReason: String? {
|
|
get { declineAndBanReasonReceivedReasonLock.withLock { declineAndBanReasonUnderlyingReceivedReason } }
|
|
set { declineAndBanReasonReceivedReasonLock.withLock { declineAndBanReasonUnderlyingReceivedReason = newValue } }
|
|
}
|
|
private let declineAndBanReasonReceivedInvocationsLock = NSLock()
|
|
private var declineAndBanReasonUnderlyingReceivedInvocations: [String?] = []
|
|
open var declineAndBanReasonReceivedInvocations: [String?] {
|
|
get { declineAndBanReasonReceivedInvocationsLock.withLock { declineAndBanReasonUnderlyingReceivedInvocations } }
|
|
set { declineAndBanReasonReceivedInvocationsLock.withLock { declineAndBanReasonUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var declineAndBanReasonClosure: ((String?) async throws -> Void)?
|
|
|
|
open override func declineAndBan(reason: String?) async throws {
|
|
if let error = declineAndBanReasonThrowableError {
|
|
throw error
|
|
}
|
|
declineAndBanReasonCallsCountLock.withLock { declineAndBanReasonUnderlyingCallsCount += 1 }
|
|
declineAndBanReasonReceivedReason = reason
|
|
declineAndBanReasonReceivedInvocationsLock.withLock { declineAndBanReasonUnderlyingReceivedInvocations.append(reason) }
|
|
try await declineAndBanReasonClosure?(reason)
|
|
}
|
|
|
|
//MARK: - markAsSeen
|
|
|
|
open var markAsSeenThrowableError: Error?
|
|
private let markAsSeenCallsCountLock = NSLock()
|
|
private var markAsSeenUnderlyingCallsCount = 0
|
|
open var markAsSeenCallsCount: Int {
|
|
get { markAsSeenCallsCountLock.withLock { markAsSeenUnderlyingCallsCount } }
|
|
set { markAsSeenCallsCountLock.withLock { markAsSeenUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var markAsSeenCalled: Bool {
|
|
return markAsSeenCallsCount > 0
|
|
}
|
|
open var markAsSeenClosure: (() async throws -> Void)?
|
|
|
|
open override func markAsSeen() async throws {
|
|
if let error = markAsSeenThrowableError {
|
|
throw error
|
|
}
|
|
markAsSeenCallsCountLock.withLock { markAsSeenUnderlyingCallsCount += 1 }
|
|
try await markAsSeenClosure?()
|
|
}
|
|
}
|
|
open class LazyTimelineItemProviderSDKMock: MatrixRustSDK.LazyTimelineItemProvider, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
|
|
//MARK: - containsOnlyEmojis
|
|
|
|
private let containsOnlyEmojisCallsCountLock = NSLock()
|
|
private var containsOnlyEmojisUnderlyingCallsCount = 0
|
|
open var containsOnlyEmojisCallsCount: Int {
|
|
get { containsOnlyEmojisCallsCountLock.withLock { containsOnlyEmojisUnderlyingCallsCount } }
|
|
set { containsOnlyEmojisCallsCountLock.withLock { containsOnlyEmojisUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var containsOnlyEmojisCalled: Bool {
|
|
return containsOnlyEmojisCallsCount > 0
|
|
}
|
|
|
|
private let containsOnlyEmojisReturnValueLock = NSLock()
|
|
open var containsOnlyEmojisUnderlyingReturnValue: Bool!
|
|
open var containsOnlyEmojisReturnValue: Bool! {
|
|
get { containsOnlyEmojisReturnValueLock.withLock { containsOnlyEmojisUnderlyingReturnValue } }
|
|
set { containsOnlyEmojisReturnValueLock.withLock { containsOnlyEmojisUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var containsOnlyEmojisClosure: (() -> Bool)?
|
|
|
|
open override func containsOnlyEmojis() -> Bool {
|
|
containsOnlyEmojisCallsCountLock.withLock { containsOnlyEmojisUnderlyingCallsCount += 1 }
|
|
if let containsOnlyEmojisClosure = containsOnlyEmojisClosure {
|
|
return containsOnlyEmojisClosure()
|
|
} else {
|
|
return containsOnlyEmojisReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - debugInfo
|
|
|
|
private let debugInfoCallsCountLock = NSLock()
|
|
private var debugInfoUnderlyingCallsCount = 0
|
|
open var debugInfoCallsCount: Int {
|
|
get { debugInfoCallsCountLock.withLock { debugInfoUnderlyingCallsCount } }
|
|
set { debugInfoCallsCountLock.withLock { debugInfoUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var debugInfoCalled: Bool {
|
|
return debugInfoCallsCount > 0
|
|
}
|
|
|
|
private let debugInfoReturnValueLock = NSLock()
|
|
open var debugInfoUnderlyingReturnValue: EventTimelineItemDebugInfo!
|
|
open var debugInfoReturnValue: EventTimelineItemDebugInfo! {
|
|
get { debugInfoReturnValueLock.withLock { debugInfoUnderlyingReturnValue } }
|
|
set { debugInfoReturnValueLock.withLock { debugInfoUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var debugInfoClosure: (() -> EventTimelineItemDebugInfo)?
|
|
|
|
open override func debugInfo() -> EventTimelineItemDebugInfo {
|
|
debugInfoCallsCountLock.withLock { debugInfoUnderlyingCallsCount += 1 }
|
|
if let debugInfoClosure = debugInfoClosure {
|
|
return debugInfoClosure()
|
|
} else {
|
|
return debugInfoReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - getSendHandle
|
|
|
|
private let getSendHandleCallsCountLock = NSLock()
|
|
private var getSendHandleUnderlyingCallsCount = 0
|
|
open var getSendHandleCallsCount: Int {
|
|
get { getSendHandleCallsCountLock.withLock { getSendHandleUnderlyingCallsCount } }
|
|
set { getSendHandleCallsCountLock.withLock { getSendHandleUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var getSendHandleCalled: Bool {
|
|
return getSendHandleCallsCount > 0
|
|
}
|
|
|
|
private let getSendHandleReturnValueLock = NSLock()
|
|
open var getSendHandleUnderlyingReturnValue: SendHandle?
|
|
open var getSendHandleReturnValue: SendHandle? {
|
|
get { getSendHandleReturnValueLock.withLock { getSendHandleUnderlyingReturnValue } }
|
|
set { getSendHandleReturnValueLock.withLock { getSendHandleUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var getSendHandleClosure: (() -> SendHandle?)?
|
|
|
|
open override func getSendHandle() -> SendHandle? {
|
|
getSendHandleCallsCountLock.withLock { getSendHandleUnderlyingCallsCount += 1 }
|
|
if let getSendHandleClosure = getSendHandleClosure {
|
|
return getSendHandleClosure()
|
|
} else {
|
|
return getSendHandleReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - getShields
|
|
|
|
private let getShieldsStrictCallsCountLock = NSLock()
|
|
private var getShieldsStrictUnderlyingCallsCount = 0
|
|
open var getShieldsStrictCallsCount: Int {
|
|
get { getShieldsStrictCallsCountLock.withLock { getShieldsStrictUnderlyingCallsCount } }
|
|
set { getShieldsStrictCallsCountLock.withLock { getShieldsStrictUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var getShieldsStrictCalled: Bool {
|
|
return getShieldsStrictCallsCount > 0
|
|
}
|
|
private let getShieldsStrictReceivedStrictLock = NSLock()
|
|
private var getShieldsStrictUnderlyingReceivedStrict: Bool?
|
|
open var getShieldsStrictReceivedStrict: Bool? {
|
|
get { getShieldsStrictReceivedStrictLock.withLock { getShieldsStrictUnderlyingReceivedStrict } }
|
|
set { getShieldsStrictReceivedStrictLock.withLock { getShieldsStrictUnderlyingReceivedStrict = newValue } }
|
|
}
|
|
private let getShieldsStrictReceivedInvocationsLock = NSLock()
|
|
private var getShieldsStrictUnderlyingReceivedInvocations: [Bool] = []
|
|
open var getShieldsStrictReceivedInvocations: [Bool] {
|
|
get { getShieldsStrictReceivedInvocationsLock.withLock { getShieldsStrictUnderlyingReceivedInvocations } }
|
|
set { getShieldsStrictReceivedInvocationsLock.withLock { getShieldsStrictUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let getShieldsStrictReturnValueLock = NSLock()
|
|
open var getShieldsStrictUnderlyingReturnValue: ShieldState!
|
|
open var getShieldsStrictReturnValue: ShieldState! {
|
|
get { getShieldsStrictReturnValueLock.withLock { getShieldsStrictUnderlyingReturnValue } }
|
|
set { getShieldsStrictReturnValueLock.withLock { getShieldsStrictUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var getShieldsStrictClosure: ((Bool) -> ShieldState)?
|
|
|
|
open override func getShields(strict: Bool) -> ShieldState {
|
|
getShieldsStrictCallsCountLock.withLock { getShieldsStrictUnderlyingCallsCount += 1 }
|
|
getShieldsStrictReceivedStrict = strict
|
|
getShieldsStrictReceivedInvocationsLock.withLock { getShieldsStrictUnderlyingReceivedInvocations.append(strict) }
|
|
if let getShieldsStrictClosure = getShieldsStrictClosure {
|
|
return getShieldsStrictClosure(strict)
|
|
} else {
|
|
return getShieldsStrictReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - latestJson
|
|
|
|
private let latestJsonCallsCountLock = NSLock()
|
|
private var latestJsonUnderlyingCallsCount = 0
|
|
open var latestJsonCallsCount: Int {
|
|
get { latestJsonCallsCountLock.withLock { latestJsonUnderlyingCallsCount } }
|
|
set { latestJsonCallsCountLock.withLock { latestJsonUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var latestJsonCalled: Bool {
|
|
return latestJsonCallsCount > 0
|
|
}
|
|
|
|
private let latestJsonReturnValueLock = NSLock()
|
|
open var latestJsonUnderlyingReturnValue: String?
|
|
open var latestJsonReturnValue: String? {
|
|
get { latestJsonReturnValueLock.withLock { latestJsonUnderlyingReturnValue } }
|
|
set { latestJsonReturnValueLock.withLock { latestJsonUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var latestJsonClosure: (() -> String?)?
|
|
|
|
open override func latestJson() -> String? {
|
|
latestJsonCallsCountLock.withLock { latestJsonUnderlyingCallsCount += 1 }
|
|
if let latestJsonClosure = latestJsonClosure {
|
|
return latestJsonClosure()
|
|
} else {
|
|
return latestJsonReturnValue
|
|
}
|
|
}
|
|
}
|
|
open class LeaveSpaceHandleSDKMock: MatrixRustSDK.LeaveSpaceHandle, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
|
|
//MARK: - leave
|
|
|
|
open var leaveRoomIdsThrowableError: Error?
|
|
private let leaveRoomIdsCallsCountLock = NSLock()
|
|
private var leaveRoomIdsUnderlyingCallsCount = 0
|
|
open var leaveRoomIdsCallsCount: Int {
|
|
get { leaveRoomIdsCallsCountLock.withLock { leaveRoomIdsUnderlyingCallsCount } }
|
|
set { leaveRoomIdsCallsCountLock.withLock { leaveRoomIdsUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var leaveRoomIdsCalled: Bool {
|
|
return leaveRoomIdsCallsCount > 0
|
|
}
|
|
private let leaveRoomIdsReceivedRoomIdsLock = NSLock()
|
|
private var leaveRoomIdsUnderlyingReceivedRoomIds: [String]?
|
|
open var leaveRoomIdsReceivedRoomIds: [String]? {
|
|
get { leaveRoomIdsReceivedRoomIdsLock.withLock { leaveRoomIdsUnderlyingReceivedRoomIds } }
|
|
set { leaveRoomIdsReceivedRoomIdsLock.withLock { leaveRoomIdsUnderlyingReceivedRoomIds = newValue } }
|
|
}
|
|
private let leaveRoomIdsReceivedInvocationsLock = NSLock()
|
|
private var leaveRoomIdsUnderlyingReceivedInvocations: [[String]] = []
|
|
open var leaveRoomIdsReceivedInvocations: [[String]] {
|
|
get { leaveRoomIdsReceivedInvocationsLock.withLock { leaveRoomIdsUnderlyingReceivedInvocations } }
|
|
set { leaveRoomIdsReceivedInvocationsLock.withLock { leaveRoomIdsUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var leaveRoomIdsClosure: (([String]) async throws -> Void)?
|
|
|
|
open override func leave(roomIds: [String]) async throws {
|
|
if let error = leaveRoomIdsThrowableError {
|
|
throw error
|
|
}
|
|
leaveRoomIdsCallsCountLock.withLock { leaveRoomIdsUnderlyingCallsCount += 1 }
|
|
leaveRoomIdsReceivedRoomIds = roomIds
|
|
leaveRoomIdsReceivedInvocationsLock.withLock { leaveRoomIdsUnderlyingReceivedInvocations.append(roomIds) }
|
|
try await leaveRoomIdsClosure?(roomIds)
|
|
}
|
|
|
|
//MARK: - rooms
|
|
|
|
private let roomsCallsCountLock = NSLock()
|
|
private var roomsUnderlyingCallsCount = 0
|
|
open var roomsCallsCount: Int {
|
|
get { roomsCallsCountLock.withLock { roomsUnderlyingCallsCount } }
|
|
set { roomsCallsCountLock.withLock { roomsUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var roomsCalled: Bool {
|
|
return roomsCallsCount > 0
|
|
}
|
|
|
|
private let roomsReturnValueLock = NSLock()
|
|
open var roomsUnderlyingReturnValue: [LeaveSpaceRoom]!
|
|
open var roomsReturnValue: [LeaveSpaceRoom]! {
|
|
get { roomsReturnValueLock.withLock { roomsUnderlyingReturnValue } }
|
|
set { roomsReturnValueLock.withLock { roomsUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var roomsClosure: (() -> [LeaveSpaceRoom])?
|
|
|
|
open override func rooms() -> [LeaveSpaceRoom] {
|
|
roomsCallsCountLock.withLock { roomsUnderlyingCallsCount += 1 }
|
|
if let roomsClosure = roomsClosure {
|
|
return roomsClosure()
|
|
} else {
|
|
return roomsReturnValue
|
|
}
|
|
}
|
|
}
|
|
open class LiveLocationsObserverSDKMock: MatrixRustSDK.LiveLocationsObserver, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
|
|
//MARK: - subscribe
|
|
|
|
private let subscribeListenerCallsCountLock = NSLock()
|
|
private var subscribeListenerUnderlyingCallsCount = 0
|
|
open var subscribeListenerCallsCount: Int {
|
|
get { subscribeListenerCallsCountLock.withLock { subscribeListenerUnderlyingCallsCount } }
|
|
set { subscribeListenerCallsCountLock.withLock { subscribeListenerUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var subscribeListenerCalled: Bool {
|
|
return subscribeListenerCallsCount > 0
|
|
}
|
|
private let subscribeListenerReceivedListenerLock = NSLock()
|
|
private var subscribeListenerUnderlyingReceivedListener: LiveLocationsListener?
|
|
open var subscribeListenerReceivedListener: LiveLocationsListener? {
|
|
get { subscribeListenerReceivedListenerLock.withLock { subscribeListenerUnderlyingReceivedListener } }
|
|
set { subscribeListenerReceivedListenerLock.withLock { subscribeListenerUnderlyingReceivedListener = newValue } }
|
|
}
|
|
private let subscribeListenerReceivedInvocationsLock = NSLock()
|
|
private var subscribeListenerUnderlyingReceivedInvocations: [LiveLocationsListener] = []
|
|
open var subscribeListenerReceivedInvocations: [LiveLocationsListener] {
|
|
get { subscribeListenerReceivedInvocationsLock.withLock { subscribeListenerUnderlyingReceivedInvocations } }
|
|
set { subscribeListenerReceivedInvocationsLock.withLock { subscribeListenerUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let subscribeListenerReturnValueLock = NSLock()
|
|
open var subscribeListenerUnderlyingReturnValue: TaskHandle!
|
|
open var subscribeListenerReturnValue: TaskHandle! {
|
|
get { subscribeListenerReturnValueLock.withLock { subscribeListenerUnderlyingReturnValue } }
|
|
set { subscribeListenerReturnValueLock.withLock { subscribeListenerUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var subscribeListenerClosure: ((LiveLocationsListener) -> TaskHandle)?
|
|
|
|
open override func subscribe(listener: LiveLocationsListener) -> TaskHandle {
|
|
subscribeListenerCallsCountLock.withLock { subscribeListenerUnderlyingCallsCount += 1 }
|
|
subscribeListenerReceivedListener = listener
|
|
subscribeListenerReceivedInvocationsLock.withLock { subscribeListenerUnderlyingReceivedInvocations.append(listener) }
|
|
if let subscribeListenerClosure = subscribeListenerClosure {
|
|
return subscribeListenerClosure(listener)
|
|
} else {
|
|
return subscribeListenerReturnValue
|
|
}
|
|
}
|
|
}
|
|
open class LoginWithQrCodeHandlerSDKMock: MatrixRustSDK.LoginWithQrCodeHandler, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
|
|
//MARK: - generate
|
|
|
|
open var generateProgressListenerThrowableError: Error?
|
|
private let generateProgressListenerCallsCountLock = NSLock()
|
|
private var generateProgressListenerUnderlyingCallsCount = 0
|
|
open var generateProgressListenerCallsCount: Int {
|
|
get { generateProgressListenerCallsCountLock.withLock { generateProgressListenerUnderlyingCallsCount } }
|
|
set { generateProgressListenerCallsCountLock.withLock { generateProgressListenerUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var generateProgressListenerCalled: Bool {
|
|
return generateProgressListenerCallsCount > 0
|
|
}
|
|
private let generateProgressListenerReceivedProgressListenerLock = NSLock()
|
|
private var generateProgressListenerUnderlyingReceivedProgressListener: GeneratedQrLoginProgressListener?
|
|
open var generateProgressListenerReceivedProgressListener: GeneratedQrLoginProgressListener? {
|
|
get { generateProgressListenerReceivedProgressListenerLock.withLock { generateProgressListenerUnderlyingReceivedProgressListener } }
|
|
set { generateProgressListenerReceivedProgressListenerLock.withLock { generateProgressListenerUnderlyingReceivedProgressListener = newValue } }
|
|
}
|
|
private let generateProgressListenerReceivedInvocationsLock = NSLock()
|
|
private var generateProgressListenerUnderlyingReceivedInvocations: [GeneratedQrLoginProgressListener] = []
|
|
open var generateProgressListenerReceivedInvocations: [GeneratedQrLoginProgressListener] {
|
|
get { generateProgressListenerReceivedInvocationsLock.withLock { generateProgressListenerUnderlyingReceivedInvocations } }
|
|
set { generateProgressListenerReceivedInvocationsLock.withLock { generateProgressListenerUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var generateProgressListenerClosure: ((GeneratedQrLoginProgressListener) async throws -> Void)?
|
|
|
|
open override func generate(progressListener: GeneratedQrLoginProgressListener) async throws {
|
|
if let error = generateProgressListenerThrowableError {
|
|
throw error
|
|
}
|
|
generateProgressListenerCallsCountLock.withLock { generateProgressListenerUnderlyingCallsCount += 1 }
|
|
generateProgressListenerReceivedProgressListener = progressListener
|
|
generateProgressListenerReceivedInvocationsLock.withLock { generateProgressListenerUnderlyingReceivedInvocations.append(progressListener) }
|
|
try await generateProgressListenerClosure?(progressListener)
|
|
}
|
|
|
|
//MARK: - scan
|
|
|
|
open var scanQrCodeDataProgressListenerThrowableError: Error?
|
|
private let scanQrCodeDataProgressListenerCallsCountLock = NSLock()
|
|
private var scanQrCodeDataProgressListenerUnderlyingCallsCount = 0
|
|
open var scanQrCodeDataProgressListenerCallsCount: Int {
|
|
get { scanQrCodeDataProgressListenerCallsCountLock.withLock { scanQrCodeDataProgressListenerUnderlyingCallsCount } }
|
|
set { scanQrCodeDataProgressListenerCallsCountLock.withLock { scanQrCodeDataProgressListenerUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var scanQrCodeDataProgressListenerCalled: Bool {
|
|
return scanQrCodeDataProgressListenerCallsCount > 0
|
|
}
|
|
private let scanQrCodeDataProgressListenerReceivedArgumentsLock = NSLock()
|
|
private var scanQrCodeDataProgressListenerUnderlyingReceivedArguments: (qrCodeData: QrCodeData, progressListener: QrLoginProgressListener)?
|
|
open var scanQrCodeDataProgressListenerReceivedArguments: (qrCodeData: QrCodeData, progressListener: QrLoginProgressListener)? {
|
|
get { scanQrCodeDataProgressListenerReceivedArgumentsLock.withLock { scanQrCodeDataProgressListenerUnderlyingReceivedArguments } }
|
|
set { scanQrCodeDataProgressListenerReceivedArgumentsLock.withLock { scanQrCodeDataProgressListenerUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let scanQrCodeDataProgressListenerReceivedInvocationsLock = NSLock()
|
|
private var scanQrCodeDataProgressListenerUnderlyingReceivedInvocations: [(qrCodeData: QrCodeData, progressListener: QrLoginProgressListener)] = []
|
|
open var scanQrCodeDataProgressListenerReceivedInvocations: [(qrCodeData: QrCodeData, progressListener: QrLoginProgressListener)] {
|
|
get { scanQrCodeDataProgressListenerReceivedInvocationsLock.withLock { scanQrCodeDataProgressListenerUnderlyingReceivedInvocations } }
|
|
set { scanQrCodeDataProgressListenerReceivedInvocationsLock.withLock { scanQrCodeDataProgressListenerUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var scanQrCodeDataProgressListenerClosure: ((QrCodeData, QrLoginProgressListener) async throws -> Void)?
|
|
|
|
open override func scan(qrCodeData: QrCodeData, progressListener: QrLoginProgressListener) async throws {
|
|
if let error = scanQrCodeDataProgressListenerThrowableError {
|
|
throw error
|
|
}
|
|
scanQrCodeDataProgressListenerCallsCountLock.withLock { scanQrCodeDataProgressListenerUnderlyingCallsCount += 1 }
|
|
scanQrCodeDataProgressListenerReceivedArguments = (qrCodeData: qrCodeData, progressListener: progressListener)
|
|
scanQrCodeDataProgressListenerReceivedInvocationsLock.withLock { scanQrCodeDataProgressListenerUnderlyingReceivedInvocations.append((qrCodeData: qrCodeData, progressListener: progressListener)) }
|
|
try await scanQrCodeDataProgressListenerClosure?(qrCodeData, progressListener)
|
|
}
|
|
}
|
|
open class MediaFileHandleSDKMock: MatrixRustSDK.MediaFileHandle, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
|
|
//MARK: - path
|
|
|
|
open var pathThrowableError: Error?
|
|
private let pathCallsCountLock = NSLock()
|
|
private var pathUnderlyingCallsCount = 0
|
|
open var pathCallsCount: Int {
|
|
get { pathCallsCountLock.withLock { pathUnderlyingCallsCount } }
|
|
set { pathCallsCountLock.withLock { pathUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var pathCalled: Bool {
|
|
return pathCallsCount > 0
|
|
}
|
|
|
|
private let pathReturnValueLock = NSLock()
|
|
open var pathUnderlyingReturnValue: String!
|
|
open var pathReturnValue: String! {
|
|
get { pathReturnValueLock.withLock { pathUnderlyingReturnValue } }
|
|
set { pathReturnValueLock.withLock { pathUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var pathClosure: (() throws -> String)?
|
|
|
|
open override func path() throws -> String {
|
|
if let error = pathThrowableError {
|
|
throw error
|
|
}
|
|
pathCallsCountLock.withLock { pathUnderlyingCallsCount += 1 }
|
|
if let pathClosure = pathClosure {
|
|
return try pathClosure()
|
|
} else {
|
|
return pathReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - persist
|
|
|
|
open var persistPathThrowableError: Error?
|
|
private let persistPathCallsCountLock = NSLock()
|
|
private var persistPathUnderlyingCallsCount = 0
|
|
open var persistPathCallsCount: Int {
|
|
get { persistPathCallsCountLock.withLock { persistPathUnderlyingCallsCount } }
|
|
set { persistPathCallsCountLock.withLock { persistPathUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var persistPathCalled: Bool {
|
|
return persistPathCallsCount > 0
|
|
}
|
|
private let persistPathReceivedPathLock = NSLock()
|
|
private var persistPathUnderlyingReceivedPath: String?
|
|
open var persistPathReceivedPath: String? {
|
|
get { persistPathReceivedPathLock.withLock { persistPathUnderlyingReceivedPath } }
|
|
set { persistPathReceivedPathLock.withLock { persistPathUnderlyingReceivedPath = newValue } }
|
|
}
|
|
private let persistPathReceivedInvocationsLock = NSLock()
|
|
private var persistPathUnderlyingReceivedInvocations: [String] = []
|
|
open var persistPathReceivedInvocations: [String] {
|
|
get { persistPathReceivedInvocationsLock.withLock { persistPathUnderlyingReceivedInvocations } }
|
|
set { persistPathReceivedInvocationsLock.withLock { persistPathUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let persistPathReturnValueLock = NSLock()
|
|
open var persistPathUnderlyingReturnValue: Bool!
|
|
open var persistPathReturnValue: Bool! {
|
|
get { persistPathReturnValueLock.withLock { persistPathUnderlyingReturnValue } }
|
|
set { persistPathReturnValueLock.withLock { persistPathUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var persistPathClosure: ((String) throws -> Bool)?
|
|
|
|
open override func persist(path: String) throws -> Bool {
|
|
if let error = persistPathThrowableError {
|
|
throw error
|
|
}
|
|
persistPathCallsCountLock.withLock { persistPathUnderlyingCallsCount += 1 }
|
|
persistPathReceivedPath = path
|
|
persistPathReceivedInvocationsLock.withLock { persistPathUnderlyingReceivedInvocations.append(path) }
|
|
if let persistPathClosure = persistPathClosure {
|
|
return try persistPathClosure(path)
|
|
} else {
|
|
return persistPathReturnValue
|
|
}
|
|
}
|
|
}
|
|
open class MediaSourceSDKMock: MatrixRustSDK.MediaSource, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
static func reset()
|
|
{
|
|
}
|
|
|
|
//MARK: - toJson
|
|
|
|
private let toJsonCallsCountLock = NSLock()
|
|
private var toJsonUnderlyingCallsCount = 0
|
|
open var toJsonCallsCount: Int {
|
|
get { toJsonCallsCountLock.withLock { toJsonUnderlyingCallsCount } }
|
|
set { toJsonCallsCountLock.withLock { toJsonUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var toJsonCalled: Bool {
|
|
return toJsonCallsCount > 0
|
|
}
|
|
|
|
private let toJsonReturnValueLock = NSLock()
|
|
open var toJsonUnderlyingReturnValue: String!
|
|
open var toJsonReturnValue: String! {
|
|
get { toJsonReturnValueLock.withLock { toJsonUnderlyingReturnValue } }
|
|
set { toJsonReturnValueLock.withLock { toJsonUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var toJsonClosure: (() -> String)?
|
|
|
|
open override func toJson() -> String {
|
|
toJsonCallsCountLock.withLock { toJsonUnderlyingCallsCount += 1 }
|
|
if let toJsonClosure = toJsonClosure {
|
|
return toJsonClosure()
|
|
} else {
|
|
return toJsonReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - url
|
|
|
|
private let urlCallsCountLock = NSLock()
|
|
private var urlUnderlyingCallsCount = 0
|
|
open var urlCallsCount: Int {
|
|
get { urlCallsCountLock.withLock { urlUnderlyingCallsCount } }
|
|
set { urlCallsCountLock.withLock { urlUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var urlCalled: Bool {
|
|
return urlCallsCount > 0
|
|
}
|
|
|
|
private let urlReturnValueLock = NSLock()
|
|
open var urlUnderlyingReturnValue: String!
|
|
open var urlReturnValue: String! {
|
|
get { urlReturnValueLock.withLock { urlUnderlyingReturnValue } }
|
|
set { urlReturnValueLock.withLock { urlUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var urlClosure: (() -> String)?
|
|
|
|
open override func url() -> String {
|
|
urlCallsCountLock.withLock { urlUnderlyingCallsCount += 1 }
|
|
if let urlClosure = urlClosure {
|
|
return urlClosure()
|
|
} else {
|
|
return urlReturnValue
|
|
}
|
|
}
|
|
}
|
|
open class NotificationClientSDKMock: MatrixRustSDK.NotificationClient, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
|
|
//MARK: - getNotification
|
|
|
|
open var getNotificationRoomIdEventIdThrowableError: Error?
|
|
private let getNotificationRoomIdEventIdCallsCountLock = NSLock()
|
|
private var getNotificationRoomIdEventIdUnderlyingCallsCount = 0
|
|
open var getNotificationRoomIdEventIdCallsCount: Int {
|
|
get { getNotificationRoomIdEventIdCallsCountLock.withLock { getNotificationRoomIdEventIdUnderlyingCallsCount } }
|
|
set { getNotificationRoomIdEventIdCallsCountLock.withLock { getNotificationRoomIdEventIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var getNotificationRoomIdEventIdCalled: Bool {
|
|
return getNotificationRoomIdEventIdCallsCount > 0
|
|
}
|
|
private let getNotificationRoomIdEventIdReceivedArgumentsLock = NSLock()
|
|
private var getNotificationRoomIdEventIdUnderlyingReceivedArguments: (roomId: String, eventId: String)?
|
|
open var getNotificationRoomIdEventIdReceivedArguments: (roomId: String, eventId: String)? {
|
|
get { getNotificationRoomIdEventIdReceivedArgumentsLock.withLock { getNotificationRoomIdEventIdUnderlyingReceivedArguments } }
|
|
set { getNotificationRoomIdEventIdReceivedArgumentsLock.withLock { getNotificationRoomIdEventIdUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let getNotificationRoomIdEventIdReceivedInvocationsLock = NSLock()
|
|
private var getNotificationRoomIdEventIdUnderlyingReceivedInvocations: [(roomId: String, eventId: String)] = []
|
|
open var getNotificationRoomIdEventIdReceivedInvocations: [(roomId: String, eventId: String)] {
|
|
get { getNotificationRoomIdEventIdReceivedInvocationsLock.withLock { getNotificationRoomIdEventIdUnderlyingReceivedInvocations } }
|
|
set { getNotificationRoomIdEventIdReceivedInvocationsLock.withLock { getNotificationRoomIdEventIdUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let getNotificationRoomIdEventIdReturnValueLock = NSLock()
|
|
open var getNotificationRoomIdEventIdUnderlyingReturnValue: NotificationStatus!
|
|
open var getNotificationRoomIdEventIdReturnValue: NotificationStatus! {
|
|
get { getNotificationRoomIdEventIdReturnValueLock.withLock { getNotificationRoomIdEventIdUnderlyingReturnValue } }
|
|
set { getNotificationRoomIdEventIdReturnValueLock.withLock { getNotificationRoomIdEventIdUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var getNotificationRoomIdEventIdClosure: ((String, String) async throws -> NotificationStatus)?
|
|
|
|
open override func getNotification(roomId: String, eventId: String) async throws -> NotificationStatus {
|
|
if let error = getNotificationRoomIdEventIdThrowableError {
|
|
throw error
|
|
}
|
|
getNotificationRoomIdEventIdCallsCountLock.withLock { getNotificationRoomIdEventIdUnderlyingCallsCount += 1 }
|
|
getNotificationRoomIdEventIdReceivedArguments = (roomId: roomId, eventId: eventId)
|
|
getNotificationRoomIdEventIdReceivedInvocationsLock.withLock { getNotificationRoomIdEventIdUnderlyingReceivedInvocations.append((roomId: roomId, eventId: eventId)) }
|
|
if let getNotificationRoomIdEventIdClosure = getNotificationRoomIdEventIdClosure {
|
|
return try await getNotificationRoomIdEventIdClosure(roomId, eventId)
|
|
} else {
|
|
return getNotificationRoomIdEventIdReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - getNotifications
|
|
|
|
open var getNotificationsRequestsThrowableError: Error?
|
|
private let getNotificationsRequestsCallsCountLock = NSLock()
|
|
private var getNotificationsRequestsUnderlyingCallsCount = 0
|
|
open var getNotificationsRequestsCallsCount: Int {
|
|
get { getNotificationsRequestsCallsCountLock.withLock { getNotificationsRequestsUnderlyingCallsCount } }
|
|
set { getNotificationsRequestsCallsCountLock.withLock { getNotificationsRequestsUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var getNotificationsRequestsCalled: Bool {
|
|
return getNotificationsRequestsCallsCount > 0
|
|
}
|
|
private let getNotificationsRequestsReceivedRequestsLock = NSLock()
|
|
private var getNotificationsRequestsUnderlyingReceivedRequests: [NotificationItemsRequest]?
|
|
open var getNotificationsRequestsReceivedRequests: [NotificationItemsRequest]? {
|
|
get { getNotificationsRequestsReceivedRequestsLock.withLock { getNotificationsRequestsUnderlyingReceivedRequests } }
|
|
set { getNotificationsRequestsReceivedRequestsLock.withLock { getNotificationsRequestsUnderlyingReceivedRequests = newValue } }
|
|
}
|
|
private let getNotificationsRequestsReceivedInvocationsLock = NSLock()
|
|
private var getNotificationsRequestsUnderlyingReceivedInvocations: [[NotificationItemsRequest]] = []
|
|
open var getNotificationsRequestsReceivedInvocations: [[NotificationItemsRequest]] {
|
|
get { getNotificationsRequestsReceivedInvocationsLock.withLock { getNotificationsRequestsUnderlyingReceivedInvocations } }
|
|
set { getNotificationsRequestsReceivedInvocationsLock.withLock { getNotificationsRequestsUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let getNotificationsRequestsReturnValueLock = NSLock()
|
|
open var getNotificationsRequestsUnderlyingReturnValue: [String: BatchNotificationResult]!
|
|
open var getNotificationsRequestsReturnValue: [String: BatchNotificationResult]! {
|
|
get { getNotificationsRequestsReturnValueLock.withLock { getNotificationsRequestsUnderlyingReturnValue } }
|
|
set { getNotificationsRequestsReturnValueLock.withLock { getNotificationsRequestsUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var getNotificationsRequestsClosure: (([NotificationItemsRequest]) async throws -> [String: BatchNotificationResult])?
|
|
|
|
open override func getNotifications(requests: [NotificationItemsRequest]) async throws -> [String: BatchNotificationResult] {
|
|
if let error = getNotificationsRequestsThrowableError {
|
|
throw error
|
|
}
|
|
getNotificationsRequestsCallsCountLock.withLock { getNotificationsRequestsUnderlyingCallsCount += 1 }
|
|
getNotificationsRequestsReceivedRequests = requests
|
|
getNotificationsRequestsReceivedInvocationsLock.withLock { getNotificationsRequestsUnderlyingReceivedInvocations.append(requests) }
|
|
if let getNotificationsRequestsClosure = getNotificationsRequestsClosure {
|
|
return try await getNotificationsRequestsClosure(requests)
|
|
} else {
|
|
return getNotificationsRequestsReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - getRoom
|
|
|
|
open var getRoomRoomIdThrowableError: Error?
|
|
private let getRoomRoomIdCallsCountLock = NSLock()
|
|
private var getRoomRoomIdUnderlyingCallsCount = 0
|
|
open var getRoomRoomIdCallsCount: Int {
|
|
get { getRoomRoomIdCallsCountLock.withLock { getRoomRoomIdUnderlyingCallsCount } }
|
|
set { getRoomRoomIdCallsCountLock.withLock { getRoomRoomIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var getRoomRoomIdCalled: Bool {
|
|
return getRoomRoomIdCallsCount > 0
|
|
}
|
|
private let getRoomRoomIdReceivedRoomIdLock = NSLock()
|
|
private var getRoomRoomIdUnderlyingReceivedRoomId: String?
|
|
open var getRoomRoomIdReceivedRoomId: String? {
|
|
get { getRoomRoomIdReceivedRoomIdLock.withLock { getRoomRoomIdUnderlyingReceivedRoomId } }
|
|
set { getRoomRoomIdReceivedRoomIdLock.withLock { getRoomRoomIdUnderlyingReceivedRoomId = newValue } }
|
|
}
|
|
private let getRoomRoomIdReceivedInvocationsLock = NSLock()
|
|
private var getRoomRoomIdUnderlyingReceivedInvocations: [String] = []
|
|
open var getRoomRoomIdReceivedInvocations: [String] {
|
|
get { getRoomRoomIdReceivedInvocationsLock.withLock { getRoomRoomIdUnderlyingReceivedInvocations } }
|
|
set { getRoomRoomIdReceivedInvocationsLock.withLock { getRoomRoomIdUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let getRoomRoomIdReturnValueLock = NSLock()
|
|
open var getRoomRoomIdUnderlyingReturnValue: Room?
|
|
open var getRoomRoomIdReturnValue: Room? {
|
|
get { getRoomRoomIdReturnValueLock.withLock { getRoomRoomIdUnderlyingReturnValue } }
|
|
set { getRoomRoomIdReturnValueLock.withLock { getRoomRoomIdUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var getRoomRoomIdClosure: ((String) throws -> Room?)?
|
|
|
|
open override func getRoom(roomId: String) throws -> Room? {
|
|
if let error = getRoomRoomIdThrowableError {
|
|
throw error
|
|
}
|
|
getRoomRoomIdCallsCountLock.withLock { getRoomRoomIdUnderlyingCallsCount += 1 }
|
|
getRoomRoomIdReceivedRoomId = roomId
|
|
getRoomRoomIdReceivedInvocationsLock.withLock { getRoomRoomIdUnderlyingReceivedInvocations.append(roomId) }
|
|
if let getRoomRoomIdClosure = getRoomRoomIdClosure {
|
|
return try getRoomRoomIdClosure(roomId)
|
|
} else {
|
|
return getRoomRoomIdReturnValue
|
|
}
|
|
}
|
|
}
|
|
open class NotificationSettingsSDKMock: MatrixRustSDK.NotificationSettings, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
|
|
//MARK: - canHomeserverPushEncryptedEventToDevice
|
|
|
|
private let canHomeserverPushEncryptedEventToDeviceCallsCountLock = NSLock()
|
|
private var canHomeserverPushEncryptedEventToDeviceUnderlyingCallsCount = 0
|
|
open var canHomeserverPushEncryptedEventToDeviceCallsCount: Int {
|
|
get { canHomeserverPushEncryptedEventToDeviceCallsCountLock.withLock { canHomeserverPushEncryptedEventToDeviceUnderlyingCallsCount } }
|
|
set { canHomeserverPushEncryptedEventToDeviceCallsCountLock.withLock { canHomeserverPushEncryptedEventToDeviceUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var canHomeserverPushEncryptedEventToDeviceCalled: Bool {
|
|
return canHomeserverPushEncryptedEventToDeviceCallsCount > 0
|
|
}
|
|
|
|
private let canHomeserverPushEncryptedEventToDeviceReturnValueLock = NSLock()
|
|
open var canHomeserverPushEncryptedEventToDeviceUnderlyingReturnValue: Bool!
|
|
open var canHomeserverPushEncryptedEventToDeviceReturnValue: Bool! {
|
|
get { canHomeserverPushEncryptedEventToDeviceReturnValueLock.withLock { canHomeserverPushEncryptedEventToDeviceUnderlyingReturnValue } }
|
|
set { canHomeserverPushEncryptedEventToDeviceReturnValueLock.withLock { canHomeserverPushEncryptedEventToDeviceUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var canHomeserverPushEncryptedEventToDeviceClosure: (() async -> Bool)?
|
|
|
|
open override func canHomeserverPushEncryptedEventToDevice() async -> Bool {
|
|
canHomeserverPushEncryptedEventToDeviceCallsCountLock.withLock { canHomeserverPushEncryptedEventToDeviceUnderlyingCallsCount += 1 }
|
|
if let canHomeserverPushEncryptedEventToDeviceClosure = canHomeserverPushEncryptedEventToDeviceClosure {
|
|
return await canHomeserverPushEncryptedEventToDeviceClosure()
|
|
} else {
|
|
return canHomeserverPushEncryptedEventToDeviceReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - canPushEncryptedEventToDevice
|
|
|
|
private let canPushEncryptedEventToDeviceCallsCountLock = NSLock()
|
|
private var canPushEncryptedEventToDeviceUnderlyingCallsCount = 0
|
|
open var canPushEncryptedEventToDeviceCallsCount: Int {
|
|
get { canPushEncryptedEventToDeviceCallsCountLock.withLock { canPushEncryptedEventToDeviceUnderlyingCallsCount } }
|
|
set { canPushEncryptedEventToDeviceCallsCountLock.withLock { canPushEncryptedEventToDeviceUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var canPushEncryptedEventToDeviceCalled: Bool {
|
|
return canPushEncryptedEventToDeviceCallsCount > 0
|
|
}
|
|
|
|
private let canPushEncryptedEventToDeviceReturnValueLock = NSLock()
|
|
open var canPushEncryptedEventToDeviceUnderlyingReturnValue: Bool!
|
|
open var canPushEncryptedEventToDeviceReturnValue: Bool! {
|
|
get { canPushEncryptedEventToDeviceReturnValueLock.withLock { canPushEncryptedEventToDeviceUnderlyingReturnValue } }
|
|
set { canPushEncryptedEventToDeviceReturnValueLock.withLock { canPushEncryptedEventToDeviceUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var canPushEncryptedEventToDeviceClosure: (() async -> Bool)?
|
|
|
|
open override func canPushEncryptedEventToDevice() async -> Bool {
|
|
canPushEncryptedEventToDeviceCallsCountLock.withLock { canPushEncryptedEventToDeviceUnderlyingCallsCount += 1 }
|
|
if let canPushEncryptedEventToDeviceClosure = canPushEncryptedEventToDeviceClosure {
|
|
return await canPushEncryptedEventToDeviceClosure()
|
|
} else {
|
|
return canPushEncryptedEventToDeviceReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - containsKeywordsRules
|
|
|
|
private let containsKeywordsRulesCallsCountLock = NSLock()
|
|
private var containsKeywordsRulesUnderlyingCallsCount = 0
|
|
open var containsKeywordsRulesCallsCount: Int {
|
|
get { containsKeywordsRulesCallsCountLock.withLock { containsKeywordsRulesUnderlyingCallsCount } }
|
|
set { containsKeywordsRulesCallsCountLock.withLock { containsKeywordsRulesUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var containsKeywordsRulesCalled: Bool {
|
|
return containsKeywordsRulesCallsCount > 0
|
|
}
|
|
|
|
private let containsKeywordsRulesReturnValueLock = NSLock()
|
|
open var containsKeywordsRulesUnderlyingReturnValue: Bool!
|
|
open var containsKeywordsRulesReturnValue: Bool! {
|
|
get { containsKeywordsRulesReturnValueLock.withLock { containsKeywordsRulesUnderlyingReturnValue } }
|
|
set { containsKeywordsRulesReturnValueLock.withLock { containsKeywordsRulesUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var containsKeywordsRulesClosure: (() async -> Bool)?
|
|
|
|
open override func containsKeywordsRules() async -> Bool {
|
|
containsKeywordsRulesCallsCountLock.withLock { containsKeywordsRulesUnderlyingCallsCount += 1 }
|
|
if let containsKeywordsRulesClosure = containsKeywordsRulesClosure {
|
|
return await containsKeywordsRulesClosure()
|
|
} else {
|
|
return containsKeywordsRulesReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - getDefaultRoomNotificationMode
|
|
|
|
private let getDefaultRoomNotificationModeIsEncryptedIsOneToOneCallsCountLock = NSLock()
|
|
private var getDefaultRoomNotificationModeIsEncryptedIsOneToOneUnderlyingCallsCount = 0
|
|
open var getDefaultRoomNotificationModeIsEncryptedIsOneToOneCallsCount: Int {
|
|
get { getDefaultRoomNotificationModeIsEncryptedIsOneToOneCallsCountLock.withLock { getDefaultRoomNotificationModeIsEncryptedIsOneToOneUnderlyingCallsCount } }
|
|
set { getDefaultRoomNotificationModeIsEncryptedIsOneToOneCallsCountLock.withLock { getDefaultRoomNotificationModeIsEncryptedIsOneToOneUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var getDefaultRoomNotificationModeIsEncryptedIsOneToOneCalled: Bool {
|
|
return getDefaultRoomNotificationModeIsEncryptedIsOneToOneCallsCount > 0
|
|
}
|
|
private let getDefaultRoomNotificationModeIsEncryptedIsOneToOneReceivedArgumentsLock = NSLock()
|
|
private var getDefaultRoomNotificationModeIsEncryptedIsOneToOneUnderlyingReceivedArguments: (isEncrypted: Bool, isOneToOne: Bool)?
|
|
open var getDefaultRoomNotificationModeIsEncryptedIsOneToOneReceivedArguments: (isEncrypted: Bool, isOneToOne: Bool)? {
|
|
get { getDefaultRoomNotificationModeIsEncryptedIsOneToOneReceivedArgumentsLock.withLock { getDefaultRoomNotificationModeIsEncryptedIsOneToOneUnderlyingReceivedArguments } }
|
|
set { getDefaultRoomNotificationModeIsEncryptedIsOneToOneReceivedArgumentsLock.withLock { getDefaultRoomNotificationModeIsEncryptedIsOneToOneUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let getDefaultRoomNotificationModeIsEncryptedIsOneToOneReceivedInvocationsLock = NSLock()
|
|
private var getDefaultRoomNotificationModeIsEncryptedIsOneToOneUnderlyingReceivedInvocations: [(isEncrypted: Bool, isOneToOne: Bool)] = []
|
|
open var getDefaultRoomNotificationModeIsEncryptedIsOneToOneReceivedInvocations: [(isEncrypted: Bool, isOneToOne: Bool)] {
|
|
get { getDefaultRoomNotificationModeIsEncryptedIsOneToOneReceivedInvocationsLock.withLock { getDefaultRoomNotificationModeIsEncryptedIsOneToOneUnderlyingReceivedInvocations } }
|
|
set { getDefaultRoomNotificationModeIsEncryptedIsOneToOneReceivedInvocationsLock.withLock { getDefaultRoomNotificationModeIsEncryptedIsOneToOneUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let getDefaultRoomNotificationModeIsEncryptedIsOneToOneReturnValueLock = NSLock()
|
|
open var getDefaultRoomNotificationModeIsEncryptedIsOneToOneUnderlyingReturnValue: RoomNotificationMode!
|
|
open var getDefaultRoomNotificationModeIsEncryptedIsOneToOneReturnValue: RoomNotificationMode! {
|
|
get { getDefaultRoomNotificationModeIsEncryptedIsOneToOneReturnValueLock.withLock { getDefaultRoomNotificationModeIsEncryptedIsOneToOneUnderlyingReturnValue } }
|
|
set { getDefaultRoomNotificationModeIsEncryptedIsOneToOneReturnValueLock.withLock { getDefaultRoomNotificationModeIsEncryptedIsOneToOneUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var getDefaultRoomNotificationModeIsEncryptedIsOneToOneClosure: ((Bool, Bool) async -> RoomNotificationMode)?
|
|
|
|
open override func getDefaultRoomNotificationMode(isEncrypted: Bool, isOneToOne: Bool) async -> RoomNotificationMode {
|
|
getDefaultRoomNotificationModeIsEncryptedIsOneToOneCallsCountLock.withLock { getDefaultRoomNotificationModeIsEncryptedIsOneToOneUnderlyingCallsCount += 1 }
|
|
getDefaultRoomNotificationModeIsEncryptedIsOneToOneReceivedArguments = (isEncrypted: isEncrypted, isOneToOne: isOneToOne)
|
|
getDefaultRoomNotificationModeIsEncryptedIsOneToOneReceivedInvocationsLock.withLock { getDefaultRoomNotificationModeIsEncryptedIsOneToOneUnderlyingReceivedInvocations.append((isEncrypted: isEncrypted, isOneToOne: isOneToOne)) }
|
|
if let getDefaultRoomNotificationModeIsEncryptedIsOneToOneClosure = getDefaultRoomNotificationModeIsEncryptedIsOneToOneClosure {
|
|
return await getDefaultRoomNotificationModeIsEncryptedIsOneToOneClosure(isEncrypted, isOneToOne)
|
|
} else {
|
|
return getDefaultRoomNotificationModeIsEncryptedIsOneToOneReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - getRawPushRules
|
|
|
|
open var getRawPushRulesThrowableError: Error?
|
|
private let getRawPushRulesCallsCountLock = NSLock()
|
|
private var getRawPushRulesUnderlyingCallsCount = 0
|
|
open var getRawPushRulesCallsCount: Int {
|
|
get { getRawPushRulesCallsCountLock.withLock { getRawPushRulesUnderlyingCallsCount } }
|
|
set { getRawPushRulesCallsCountLock.withLock { getRawPushRulesUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var getRawPushRulesCalled: Bool {
|
|
return getRawPushRulesCallsCount > 0
|
|
}
|
|
|
|
private let getRawPushRulesReturnValueLock = NSLock()
|
|
open var getRawPushRulesUnderlyingReturnValue: String?
|
|
open var getRawPushRulesReturnValue: String? {
|
|
get { getRawPushRulesReturnValueLock.withLock { getRawPushRulesUnderlyingReturnValue } }
|
|
set { getRawPushRulesReturnValueLock.withLock { getRawPushRulesUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var getRawPushRulesClosure: (() async throws -> String?)?
|
|
|
|
open override func getRawPushRules() async throws -> String? {
|
|
if let error = getRawPushRulesThrowableError {
|
|
throw error
|
|
}
|
|
getRawPushRulesCallsCountLock.withLock { getRawPushRulesUnderlyingCallsCount += 1 }
|
|
if let getRawPushRulesClosure = getRawPushRulesClosure {
|
|
return try await getRawPushRulesClosure()
|
|
} else {
|
|
return getRawPushRulesReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - getRoomNotificationSettings
|
|
|
|
open var getRoomNotificationSettingsRoomIdIsEncryptedIsOneToOneThrowableError: Error?
|
|
private let getRoomNotificationSettingsRoomIdIsEncryptedIsOneToOneCallsCountLock = NSLock()
|
|
private var getRoomNotificationSettingsRoomIdIsEncryptedIsOneToOneUnderlyingCallsCount = 0
|
|
open var getRoomNotificationSettingsRoomIdIsEncryptedIsOneToOneCallsCount: Int {
|
|
get { getRoomNotificationSettingsRoomIdIsEncryptedIsOneToOneCallsCountLock.withLock { getRoomNotificationSettingsRoomIdIsEncryptedIsOneToOneUnderlyingCallsCount } }
|
|
set { getRoomNotificationSettingsRoomIdIsEncryptedIsOneToOneCallsCountLock.withLock { getRoomNotificationSettingsRoomIdIsEncryptedIsOneToOneUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var getRoomNotificationSettingsRoomIdIsEncryptedIsOneToOneCalled: Bool {
|
|
return getRoomNotificationSettingsRoomIdIsEncryptedIsOneToOneCallsCount > 0
|
|
}
|
|
private let getRoomNotificationSettingsRoomIdIsEncryptedIsOneToOneReceivedArgumentsLock = NSLock()
|
|
private var getRoomNotificationSettingsRoomIdIsEncryptedIsOneToOneUnderlyingReceivedArguments: (roomId: String, isEncrypted: Bool, isOneToOne: Bool)?
|
|
open var getRoomNotificationSettingsRoomIdIsEncryptedIsOneToOneReceivedArguments: (roomId: String, isEncrypted: Bool, isOneToOne: Bool)? {
|
|
get { getRoomNotificationSettingsRoomIdIsEncryptedIsOneToOneReceivedArgumentsLock.withLock { getRoomNotificationSettingsRoomIdIsEncryptedIsOneToOneUnderlyingReceivedArguments } }
|
|
set { getRoomNotificationSettingsRoomIdIsEncryptedIsOneToOneReceivedArgumentsLock.withLock { getRoomNotificationSettingsRoomIdIsEncryptedIsOneToOneUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let getRoomNotificationSettingsRoomIdIsEncryptedIsOneToOneReceivedInvocationsLock = NSLock()
|
|
private var getRoomNotificationSettingsRoomIdIsEncryptedIsOneToOneUnderlyingReceivedInvocations: [(roomId: String, isEncrypted: Bool, isOneToOne: Bool)] = []
|
|
open var getRoomNotificationSettingsRoomIdIsEncryptedIsOneToOneReceivedInvocations: [(roomId: String, isEncrypted: Bool, isOneToOne: Bool)] {
|
|
get { getRoomNotificationSettingsRoomIdIsEncryptedIsOneToOneReceivedInvocationsLock.withLock { getRoomNotificationSettingsRoomIdIsEncryptedIsOneToOneUnderlyingReceivedInvocations } }
|
|
set { getRoomNotificationSettingsRoomIdIsEncryptedIsOneToOneReceivedInvocationsLock.withLock { getRoomNotificationSettingsRoomIdIsEncryptedIsOneToOneUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let getRoomNotificationSettingsRoomIdIsEncryptedIsOneToOneReturnValueLock = NSLock()
|
|
open var getRoomNotificationSettingsRoomIdIsEncryptedIsOneToOneUnderlyingReturnValue: RoomNotificationSettings!
|
|
open var getRoomNotificationSettingsRoomIdIsEncryptedIsOneToOneReturnValue: RoomNotificationSettings! {
|
|
get { getRoomNotificationSettingsRoomIdIsEncryptedIsOneToOneReturnValueLock.withLock { getRoomNotificationSettingsRoomIdIsEncryptedIsOneToOneUnderlyingReturnValue } }
|
|
set { getRoomNotificationSettingsRoomIdIsEncryptedIsOneToOneReturnValueLock.withLock { getRoomNotificationSettingsRoomIdIsEncryptedIsOneToOneUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var getRoomNotificationSettingsRoomIdIsEncryptedIsOneToOneClosure: ((String, Bool, Bool) async throws -> RoomNotificationSettings)?
|
|
|
|
open override func getRoomNotificationSettings(roomId: String, isEncrypted: Bool, isOneToOne: Bool) async throws -> RoomNotificationSettings {
|
|
if let error = getRoomNotificationSettingsRoomIdIsEncryptedIsOneToOneThrowableError {
|
|
throw error
|
|
}
|
|
getRoomNotificationSettingsRoomIdIsEncryptedIsOneToOneCallsCountLock.withLock { getRoomNotificationSettingsRoomIdIsEncryptedIsOneToOneUnderlyingCallsCount += 1 }
|
|
getRoomNotificationSettingsRoomIdIsEncryptedIsOneToOneReceivedArguments = (roomId: roomId, isEncrypted: isEncrypted, isOneToOne: isOneToOne)
|
|
getRoomNotificationSettingsRoomIdIsEncryptedIsOneToOneReceivedInvocationsLock.withLock { getRoomNotificationSettingsRoomIdIsEncryptedIsOneToOneUnderlyingReceivedInvocations.append((roomId: roomId, isEncrypted: isEncrypted, isOneToOne: isOneToOne)) }
|
|
if let getRoomNotificationSettingsRoomIdIsEncryptedIsOneToOneClosure = getRoomNotificationSettingsRoomIdIsEncryptedIsOneToOneClosure {
|
|
return try await getRoomNotificationSettingsRoomIdIsEncryptedIsOneToOneClosure(roomId, isEncrypted, isOneToOne)
|
|
} else {
|
|
return getRoomNotificationSettingsRoomIdIsEncryptedIsOneToOneReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - getRoomsWithUserDefinedRules
|
|
|
|
private let getRoomsWithUserDefinedRulesEnabledCallsCountLock = NSLock()
|
|
private var getRoomsWithUserDefinedRulesEnabledUnderlyingCallsCount = 0
|
|
open var getRoomsWithUserDefinedRulesEnabledCallsCount: Int {
|
|
get { getRoomsWithUserDefinedRulesEnabledCallsCountLock.withLock { getRoomsWithUserDefinedRulesEnabledUnderlyingCallsCount } }
|
|
set { getRoomsWithUserDefinedRulesEnabledCallsCountLock.withLock { getRoomsWithUserDefinedRulesEnabledUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var getRoomsWithUserDefinedRulesEnabledCalled: Bool {
|
|
return getRoomsWithUserDefinedRulesEnabledCallsCount > 0
|
|
}
|
|
private let getRoomsWithUserDefinedRulesEnabledReceivedEnabledLock = NSLock()
|
|
private var getRoomsWithUserDefinedRulesEnabledUnderlyingReceivedEnabled: Bool?
|
|
open var getRoomsWithUserDefinedRulesEnabledReceivedEnabled: Bool? {
|
|
get { getRoomsWithUserDefinedRulesEnabledReceivedEnabledLock.withLock { getRoomsWithUserDefinedRulesEnabledUnderlyingReceivedEnabled } }
|
|
set { getRoomsWithUserDefinedRulesEnabledReceivedEnabledLock.withLock { getRoomsWithUserDefinedRulesEnabledUnderlyingReceivedEnabled = newValue } }
|
|
}
|
|
private let getRoomsWithUserDefinedRulesEnabledReceivedInvocationsLock = NSLock()
|
|
private var getRoomsWithUserDefinedRulesEnabledUnderlyingReceivedInvocations: [Bool?] = []
|
|
open var getRoomsWithUserDefinedRulesEnabledReceivedInvocations: [Bool?] {
|
|
get { getRoomsWithUserDefinedRulesEnabledReceivedInvocationsLock.withLock { getRoomsWithUserDefinedRulesEnabledUnderlyingReceivedInvocations } }
|
|
set { getRoomsWithUserDefinedRulesEnabledReceivedInvocationsLock.withLock { getRoomsWithUserDefinedRulesEnabledUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let getRoomsWithUserDefinedRulesEnabledReturnValueLock = NSLock()
|
|
open var getRoomsWithUserDefinedRulesEnabledUnderlyingReturnValue: [String]!
|
|
open var getRoomsWithUserDefinedRulesEnabledReturnValue: [String]! {
|
|
get { getRoomsWithUserDefinedRulesEnabledReturnValueLock.withLock { getRoomsWithUserDefinedRulesEnabledUnderlyingReturnValue } }
|
|
set { getRoomsWithUserDefinedRulesEnabledReturnValueLock.withLock { getRoomsWithUserDefinedRulesEnabledUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var getRoomsWithUserDefinedRulesEnabledClosure: ((Bool?) async -> [String])?
|
|
|
|
open override func getRoomsWithUserDefinedRules(enabled: Bool?) async -> [String] {
|
|
getRoomsWithUserDefinedRulesEnabledCallsCountLock.withLock { getRoomsWithUserDefinedRulesEnabledUnderlyingCallsCount += 1 }
|
|
getRoomsWithUserDefinedRulesEnabledReceivedEnabled = enabled
|
|
getRoomsWithUserDefinedRulesEnabledReceivedInvocationsLock.withLock { getRoomsWithUserDefinedRulesEnabledUnderlyingReceivedInvocations.append(enabled) }
|
|
if let getRoomsWithUserDefinedRulesEnabledClosure = getRoomsWithUserDefinedRulesEnabledClosure {
|
|
return await getRoomsWithUserDefinedRulesEnabledClosure(enabled)
|
|
} else {
|
|
return getRoomsWithUserDefinedRulesEnabledReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - getUserDefinedRoomNotificationMode
|
|
|
|
open var getUserDefinedRoomNotificationModeRoomIdThrowableError: Error?
|
|
private let getUserDefinedRoomNotificationModeRoomIdCallsCountLock = NSLock()
|
|
private var getUserDefinedRoomNotificationModeRoomIdUnderlyingCallsCount = 0
|
|
open var getUserDefinedRoomNotificationModeRoomIdCallsCount: Int {
|
|
get { getUserDefinedRoomNotificationModeRoomIdCallsCountLock.withLock { getUserDefinedRoomNotificationModeRoomIdUnderlyingCallsCount } }
|
|
set { getUserDefinedRoomNotificationModeRoomIdCallsCountLock.withLock { getUserDefinedRoomNotificationModeRoomIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var getUserDefinedRoomNotificationModeRoomIdCalled: Bool {
|
|
return getUserDefinedRoomNotificationModeRoomIdCallsCount > 0
|
|
}
|
|
private let getUserDefinedRoomNotificationModeRoomIdReceivedRoomIdLock = NSLock()
|
|
private var getUserDefinedRoomNotificationModeRoomIdUnderlyingReceivedRoomId: String?
|
|
open var getUserDefinedRoomNotificationModeRoomIdReceivedRoomId: String? {
|
|
get { getUserDefinedRoomNotificationModeRoomIdReceivedRoomIdLock.withLock { getUserDefinedRoomNotificationModeRoomIdUnderlyingReceivedRoomId } }
|
|
set { getUserDefinedRoomNotificationModeRoomIdReceivedRoomIdLock.withLock { getUserDefinedRoomNotificationModeRoomIdUnderlyingReceivedRoomId = newValue } }
|
|
}
|
|
private let getUserDefinedRoomNotificationModeRoomIdReceivedInvocationsLock = NSLock()
|
|
private var getUserDefinedRoomNotificationModeRoomIdUnderlyingReceivedInvocations: [String] = []
|
|
open var getUserDefinedRoomNotificationModeRoomIdReceivedInvocations: [String] {
|
|
get { getUserDefinedRoomNotificationModeRoomIdReceivedInvocationsLock.withLock { getUserDefinedRoomNotificationModeRoomIdUnderlyingReceivedInvocations } }
|
|
set { getUserDefinedRoomNotificationModeRoomIdReceivedInvocationsLock.withLock { getUserDefinedRoomNotificationModeRoomIdUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let getUserDefinedRoomNotificationModeRoomIdReturnValueLock = NSLock()
|
|
open var getUserDefinedRoomNotificationModeRoomIdUnderlyingReturnValue: RoomNotificationMode?
|
|
open var getUserDefinedRoomNotificationModeRoomIdReturnValue: RoomNotificationMode? {
|
|
get { getUserDefinedRoomNotificationModeRoomIdReturnValueLock.withLock { getUserDefinedRoomNotificationModeRoomIdUnderlyingReturnValue } }
|
|
set { getUserDefinedRoomNotificationModeRoomIdReturnValueLock.withLock { getUserDefinedRoomNotificationModeRoomIdUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var getUserDefinedRoomNotificationModeRoomIdClosure: ((String) async throws -> RoomNotificationMode?)?
|
|
|
|
open override func getUserDefinedRoomNotificationMode(roomId: String) async throws -> RoomNotificationMode? {
|
|
if let error = getUserDefinedRoomNotificationModeRoomIdThrowableError {
|
|
throw error
|
|
}
|
|
getUserDefinedRoomNotificationModeRoomIdCallsCountLock.withLock { getUserDefinedRoomNotificationModeRoomIdUnderlyingCallsCount += 1 }
|
|
getUserDefinedRoomNotificationModeRoomIdReceivedRoomId = roomId
|
|
getUserDefinedRoomNotificationModeRoomIdReceivedInvocationsLock.withLock { getUserDefinedRoomNotificationModeRoomIdUnderlyingReceivedInvocations.append(roomId) }
|
|
if let getUserDefinedRoomNotificationModeRoomIdClosure = getUserDefinedRoomNotificationModeRoomIdClosure {
|
|
return try await getUserDefinedRoomNotificationModeRoomIdClosure(roomId)
|
|
} else {
|
|
return getUserDefinedRoomNotificationModeRoomIdReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - isCallEnabled
|
|
|
|
open var isCallEnabledThrowableError: Error?
|
|
private let isCallEnabledCallsCountLock = NSLock()
|
|
private var isCallEnabledUnderlyingCallsCount = 0
|
|
open var isCallEnabledCallsCount: Int {
|
|
get { isCallEnabledCallsCountLock.withLock { isCallEnabledUnderlyingCallsCount } }
|
|
set { isCallEnabledCallsCountLock.withLock { isCallEnabledUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var isCallEnabledCalled: Bool {
|
|
return isCallEnabledCallsCount > 0
|
|
}
|
|
|
|
private let isCallEnabledReturnValueLock = NSLock()
|
|
open var isCallEnabledUnderlyingReturnValue: Bool!
|
|
open var isCallEnabledReturnValue: Bool! {
|
|
get { isCallEnabledReturnValueLock.withLock { isCallEnabledUnderlyingReturnValue } }
|
|
set { isCallEnabledReturnValueLock.withLock { isCallEnabledUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var isCallEnabledClosure: (() async throws -> Bool)?
|
|
|
|
open override func isCallEnabled() async throws -> Bool {
|
|
if let error = isCallEnabledThrowableError {
|
|
throw error
|
|
}
|
|
isCallEnabledCallsCountLock.withLock { isCallEnabledUnderlyingCallsCount += 1 }
|
|
if let isCallEnabledClosure = isCallEnabledClosure {
|
|
return try await isCallEnabledClosure()
|
|
} else {
|
|
return isCallEnabledReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - isInviteForMeEnabled
|
|
|
|
open var isInviteForMeEnabledThrowableError: Error?
|
|
private let isInviteForMeEnabledCallsCountLock = NSLock()
|
|
private var isInviteForMeEnabledUnderlyingCallsCount = 0
|
|
open var isInviteForMeEnabledCallsCount: Int {
|
|
get { isInviteForMeEnabledCallsCountLock.withLock { isInviteForMeEnabledUnderlyingCallsCount } }
|
|
set { isInviteForMeEnabledCallsCountLock.withLock { isInviteForMeEnabledUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var isInviteForMeEnabledCalled: Bool {
|
|
return isInviteForMeEnabledCallsCount > 0
|
|
}
|
|
|
|
private let isInviteForMeEnabledReturnValueLock = NSLock()
|
|
open var isInviteForMeEnabledUnderlyingReturnValue: Bool!
|
|
open var isInviteForMeEnabledReturnValue: Bool! {
|
|
get { isInviteForMeEnabledReturnValueLock.withLock { isInviteForMeEnabledUnderlyingReturnValue } }
|
|
set { isInviteForMeEnabledReturnValueLock.withLock { isInviteForMeEnabledUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var isInviteForMeEnabledClosure: (() async throws -> Bool)?
|
|
|
|
open override func isInviteForMeEnabled() async throws -> Bool {
|
|
if let error = isInviteForMeEnabledThrowableError {
|
|
throw error
|
|
}
|
|
isInviteForMeEnabledCallsCountLock.withLock { isInviteForMeEnabledUnderlyingCallsCount += 1 }
|
|
if let isInviteForMeEnabledClosure = isInviteForMeEnabledClosure {
|
|
return try await isInviteForMeEnabledClosure()
|
|
} else {
|
|
return isInviteForMeEnabledReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - isRoomMentionEnabled
|
|
|
|
open var isRoomMentionEnabledThrowableError: Error?
|
|
private let isRoomMentionEnabledCallsCountLock = NSLock()
|
|
private var isRoomMentionEnabledUnderlyingCallsCount = 0
|
|
open var isRoomMentionEnabledCallsCount: Int {
|
|
get { isRoomMentionEnabledCallsCountLock.withLock { isRoomMentionEnabledUnderlyingCallsCount } }
|
|
set { isRoomMentionEnabledCallsCountLock.withLock { isRoomMentionEnabledUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var isRoomMentionEnabledCalled: Bool {
|
|
return isRoomMentionEnabledCallsCount > 0
|
|
}
|
|
|
|
private let isRoomMentionEnabledReturnValueLock = NSLock()
|
|
open var isRoomMentionEnabledUnderlyingReturnValue: Bool!
|
|
open var isRoomMentionEnabledReturnValue: Bool! {
|
|
get { isRoomMentionEnabledReturnValueLock.withLock { isRoomMentionEnabledUnderlyingReturnValue } }
|
|
set { isRoomMentionEnabledReturnValueLock.withLock { isRoomMentionEnabledUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var isRoomMentionEnabledClosure: (() async throws -> Bool)?
|
|
|
|
open override func isRoomMentionEnabled() async throws -> Bool {
|
|
if let error = isRoomMentionEnabledThrowableError {
|
|
throw error
|
|
}
|
|
isRoomMentionEnabledCallsCountLock.withLock { isRoomMentionEnabledUnderlyingCallsCount += 1 }
|
|
if let isRoomMentionEnabledClosure = isRoomMentionEnabledClosure {
|
|
return try await isRoomMentionEnabledClosure()
|
|
} else {
|
|
return isRoomMentionEnabledReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - isUserMentionEnabled
|
|
|
|
open var isUserMentionEnabledThrowableError: Error?
|
|
private let isUserMentionEnabledCallsCountLock = NSLock()
|
|
private var isUserMentionEnabledUnderlyingCallsCount = 0
|
|
open var isUserMentionEnabledCallsCount: Int {
|
|
get { isUserMentionEnabledCallsCountLock.withLock { isUserMentionEnabledUnderlyingCallsCount } }
|
|
set { isUserMentionEnabledCallsCountLock.withLock { isUserMentionEnabledUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var isUserMentionEnabledCalled: Bool {
|
|
return isUserMentionEnabledCallsCount > 0
|
|
}
|
|
|
|
private let isUserMentionEnabledReturnValueLock = NSLock()
|
|
open var isUserMentionEnabledUnderlyingReturnValue: Bool!
|
|
open var isUserMentionEnabledReturnValue: Bool! {
|
|
get { isUserMentionEnabledReturnValueLock.withLock { isUserMentionEnabledUnderlyingReturnValue } }
|
|
set { isUserMentionEnabledReturnValueLock.withLock { isUserMentionEnabledUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var isUserMentionEnabledClosure: (() async throws -> Bool)?
|
|
|
|
open override func isUserMentionEnabled() async throws -> Bool {
|
|
if let error = isUserMentionEnabledThrowableError {
|
|
throw error
|
|
}
|
|
isUserMentionEnabledCallsCountLock.withLock { isUserMentionEnabledUnderlyingCallsCount += 1 }
|
|
if let isUserMentionEnabledClosure = isUserMentionEnabledClosure {
|
|
return try await isUserMentionEnabledClosure()
|
|
} else {
|
|
return isUserMentionEnabledReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - restoreDefaultRoomNotificationMode
|
|
|
|
open var restoreDefaultRoomNotificationModeRoomIdThrowableError: Error?
|
|
private let restoreDefaultRoomNotificationModeRoomIdCallsCountLock = NSLock()
|
|
private var restoreDefaultRoomNotificationModeRoomIdUnderlyingCallsCount = 0
|
|
open var restoreDefaultRoomNotificationModeRoomIdCallsCount: Int {
|
|
get { restoreDefaultRoomNotificationModeRoomIdCallsCountLock.withLock { restoreDefaultRoomNotificationModeRoomIdUnderlyingCallsCount } }
|
|
set { restoreDefaultRoomNotificationModeRoomIdCallsCountLock.withLock { restoreDefaultRoomNotificationModeRoomIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var restoreDefaultRoomNotificationModeRoomIdCalled: Bool {
|
|
return restoreDefaultRoomNotificationModeRoomIdCallsCount > 0
|
|
}
|
|
private let restoreDefaultRoomNotificationModeRoomIdReceivedRoomIdLock = NSLock()
|
|
private var restoreDefaultRoomNotificationModeRoomIdUnderlyingReceivedRoomId: String?
|
|
open var restoreDefaultRoomNotificationModeRoomIdReceivedRoomId: String? {
|
|
get { restoreDefaultRoomNotificationModeRoomIdReceivedRoomIdLock.withLock { restoreDefaultRoomNotificationModeRoomIdUnderlyingReceivedRoomId } }
|
|
set { restoreDefaultRoomNotificationModeRoomIdReceivedRoomIdLock.withLock { restoreDefaultRoomNotificationModeRoomIdUnderlyingReceivedRoomId = newValue } }
|
|
}
|
|
private let restoreDefaultRoomNotificationModeRoomIdReceivedInvocationsLock = NSLock()
|
|
private var restoreDefaultRoomNotificationModeRoomIdUnderlyingReceivedInvocations: [String] = []
|
|
open var restoreDefaultRoomNotificationModeRoomIdReceivedInvocations: [String] {
|
|
get { restoreDefaultRoomNotificationModeRoomIdReceivedInvocationsLock.withLock { restoreDefaultRoomNotificationModeRoomIdUnderlyingReceivedInvocations } }
|
|
set { restoreDefaultRoomNotificationModeRoomIdReceivedInvocationsLock.withLock { restoreDefaultRoomNotificationModeRoomIdUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var restoreDefaultRoomNotificationModeRoomIdClosure: ((String) async throws -> Void)?
|
|
|
|
open override func restoreDefaultRoomNotificationMode(roomId: String) async throws {
|
|
if let error = restoreDefaultRoomNotificationModeRoomIdThrowableError {
|
|
throw error
|
|
}
|
|
restoreDefaultRoomNotificationModeRoomIdCallsCountLock.withLock { restoreDefaultRoomNotificationModeRoomIdUnderlyingCallsCount += 1 }
|
|
restoreDefaultRoomNotificationModeRoomIdReceivedRoomId = roomId
|
|
restoreDefaultRoomNotificationModeRoomIdReceivedInvocationsLock.withLock { restoreDefaultRoomNotificationModeRoomIdUnderlyingReceivedInvocations.append(roomId) }
|
|
try await restoreDefaultRoomNotificationModeRoomIdClosure?(roomId)
|
|
}
|
|
|
|
//MARK: - setCallEnabled
|
|
|
|
open var setCallEnabledEnabledThrowableError: Error?
|
|
private let setCallEnabledEnabledCallsCountLock = NSLock()
|
|
private var setCallEnabledEnabledUnderlyingCallsCount = 0
|
|
open var setCallEnabledEnabledCallsCount: Int {
|
|
get { setCallEnabledEnabledCallsCountLock.withLock { setCallEnabledEnabledUnderlyingCallsCount } }
|
|
set { setCallEnabledEnabledCallsCountLock.withLock { setCallEnabledEnabledUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var setCallEnabledEnabledCalled: Bool {
|
|
return setCallEnabledEnabledCallsCount > 0
|
|
}
|
|
private let setCallEnabledEnabledReceivedEnabledLock = NSLock()
|
|
private var setCallEnabledEnabledUnderlyingReceivedEnabled: Bool?
|
|
open var setCallEnabledEnabledReceivedEnabled: Bool? {
|
|
get { setCallEnabledEnabledReceivedEnabledLock.withLock { setCallEnabledEnabledUnderlyingReceivedEnabled } }
|
|
set { setCallEnabledEnabledReceivedEnabledLock.withLock { setCallEnabledEnabledUnderlyingReceivedEnabled = newValue } }
|
|
}
|
|
private let setCallEnabledEnabledReceivedInvocationsLock = NSLock()
|
|
private var setCallEnabledEnabledUnderlyingReceivedInvocations: [Bool] = []
|
|
open var setCallEnabledEnabledReceivedInvocations: [Bool] {
|
|
get { setCallEnabledEnabledReceivedInvocationsLock.withLock { setCallEnabledEnabledUnderlyingReceivedInvocations } }
|
|
set { setCallEnabledEnabledReceivedInvocationsLock.withLock { setCallEnabledEnabledUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var setCallEnabledEnabledClosure: ((Bool) async throws -> Void)?
|
|
|
|
open override func setCallEnabled(enabled: Bool) async throws {
|
|
if let error = setCallEnabledEnabledThrowableError {
|
|
throw error
|
|
}
|
|
setCallEnabledEnabledCallsCountLock.withLock { setCallEnabledEnabledUnderlyingCallsCount += 1 }
|
|
setCallEnabledEnabledReceivedEnabled = enabled
|
|
setCallEnabledEnabledReceivedInvocationsLock.withLock { setCallEnabledEnabledUnderlyingReceivedInvocations.append(enabled) }
|
|
try await setCallEnabledEnabledClosure?(enabled)
|
|
}
|
|
|
|
//MARK: - setCustomPushRule
|
|
|
|
open var setCustomPushRuleRuleIdRuleKindActionsConditionsThrowableError: Error?
|
|
private let setCustomPushRuleRuleIdRuleKindActionsConditionsCallsCountLock = NSLock()
|
|
private var setCustomPushRuleRuleIdRuleKindActionsConditionsUnderlyingCallsCount = 0
|
|
open var setCustomPushRuleRuleIdRuleKindActionsConditionsCallsCount: Int {
|
|
get { setCustomPushRuleRuleIdRuleKindActionsConditionsCallsCountLock.withLock { setCustomPushRuleRuleIdRuleKindActionsConditionsUnderlyingCallsCount } }
|
|
set { setCustomPushRuleRuleIdRuleKindActionsConditionsCallsCountLock.withLock { setCustomPushRuleRuleIdRuleKindActionsConditionsUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var setCustomPushRuleRuleIdRuleKindActionsConditionsCalled: Bool {
|
|
return setCustomPushRuleRuleIdRuleKindActionsConditionsCallsCount > 0
|
|
}
|
|
private let setCustomPushRuleRuleIdRuleKindActionsConditionsReceivedArgumentsLock = NSLock()
|
|
private var setCustomPushRuleRuleIdRuleKindActionsConditionsUnderlyingReceivedArguments: (ruleId: String, ruleKind: RuleKind, actions: [Action], conditions: [PushCondition])?
|
|
open var setCustomPushRuleRuleIdRuleKindActionsConditionsReceivedArguments: (ruleId: String, ruleKind: RuleKind, actions: [Action], conditions: [PushCondition])? {
|
|
get { setCustomPushRuleRuleIdRuleKindActionsConditionsReceivedArgumentsLock.withLock { setCustomPushRuleRuleIdRuleKindActionsConditionsUnderlyingReceivedArguments } }
|
|
set { setCustomPushRuleRuleIdRuleKindActionsConditionsReceivedArgumentsLock.withLock { setCustomPushRuleRuleIdRuleKindActionsConditionsUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let setCustomPushRuleRuleIdRuleKindActionsConditionsReceivedInvocationsLock = NSLock()
|
|
private var setCustomPushRuleRuleIdRuleKindActionsConditionsUnderlyingReceivedInvocations: [(ruleId: String, ruleKind: RuleKind, actions: [Action], conditions: [PushCondition])] = []
|
|
open var setCustomPushRuleRuleIdRuleKindActionsConditionsReceivedInvocations: [(ruleId: String, ruleKind: RuleKind, actions: [Action], conditions: [PushCondition])] {
|
|
get { setCustomPushRuleRuleIdRuleKindActionsConditionsReceivedInvocationsLock.withLock { setCustomPushRuleRuleIdRuleKindActionsConditionsUnderlyingReceivedInvocations } }
|
|
set { setCustomPushRuleRuleIdRuleKindActionsConditionsReceivedInvocationsLock.withLock { setCustomPushRuleRuleIdRuleKindActionsConditionsUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var setCustomPushRuleRuleIdRuleKindActionsConditionsClosure: ((String, RuleKind, [Action], [PushCondition]) async throws -> Void)?
|
|
|
|
open override func setCustomPushRule(ruleId: String, ruleKind: RuleKind, actions: [Action], conditions: [PushCondition]) async throws {
|
|
if let error = setCustomPushRuleRuleIdRuleKindActionsConditionsThrowableError {
|
|
throw error
|
|
}
|
|
setCustomPushRuleRuleIdRuleKindActionsConditionsCallsCountLock.withLock { setCustomPushRuleRuleIdRuleKindActionsConditionsUnderlyingCallsCount += 1 }
|
|
setCustomPushRuleRuleIdRuleKindActionsConditionsReceivedArguments = (ruleId: ruleId, ruleKind: ruleKind, actions: actions, conditions: conditions)
|
|
setCustomPushRuleRuleIdRuleKindActionsConditionsReceivedInvocationsLock.withLock { setCustomPushRuleRuleIdRuleKindActionsConditionsUnderlyingReceivedInvocations.append((ruleId: ruleId, ruleKind: ruleKind, actions: actions, conditions: conditions)) }
|
|
try await setCustomPushRuleRuleIdRuleKindActionsConditionsClosure?(ruleId, ruleKind, actions, conditions)
|
|
}
|
|
|
|
//MARK: - setDefaultRoomNotificationMode
|
|
|
|
open var setDefaultRoomNotificationModeIsEncryptedIsOneToOneModeThrowableError: Error?
|
|
private let setDefaultRoomNotificationModeIsEncryptedIsOneToOneModeCallsCountLock = NSLock()
|
|
private var setDefaultRoomNotificationModeIsEncryptedIsOneToOneModeUnderlyingCallsCount = 0
|
|
open var setDefaultRoomNotificationModeIsEncryptedIsOneToOneModeCallsCount: Int {
|
|
get { setDefaultRoomNotificationModeIsEncryptedIsOneToOneModeCallsCountLock.withLock { setDefaultRoomNotificationModeIsEncryptedIsOneToOneModeUnderlyingCallsCount } }
|
|
set { setDefaultRoomNotificationModeIsEncryptedIsOneToOneModeCallsCountLock.withLock { setDefaultRoomNotificationModeIsEncryptedIsOneToOneModeUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var setDefaultRoomNotificationModeIsEncryptedIsOneToOneModeCalled: Bool {
|
|
return setDefaultRoomNotificationModeIsEncryptedIsOneToOneModeCallsCount > 0
|
|
}
|
|
private let setDefaultRoomNotificationModeIsEncryptedIsOneToOneModeReceivedArgumentsLock = NSLock()
|
|
private var setDefaultRoomNotificationModeIsEncryptedIsOneToOneModeUnderlyingReceivedArguments: (isEncrypted: Bool, isOneToOne: Bool, mode: RoomNotificationMode)?
|
|
open var setDefaultRoomNotificationModeIsEncryptedIsOneToOneModeReceivedArguments: (isEncrypted: Bool, isOneToOne: Bool, mode: RoomNotificationMode)? {
|
|
get { setDefaultRoomNotificationModeIsEncryptedIsOneToOneModeReceivedArgumentsLock.withLock { setDefaultRoomNotificationModeIsEncryptedIsOneToOneModeUnderlyingReceivedArguments } }
|
|
set { setDefaultRoomNotificationModeIsEncryptedIsOneToOneModeReceivedArgumentsLock.withLock { setDefaultRoomNotificationModeIsEncryptedIsOneToOneModeUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let setDefaultRoomNotificationModeIsEncryptedIsOneToOneModeReceivedInvocationsLock = NSLock()
|
|
private var setDefaultRoomNotificationModeIsEncryptedIsOneToOneModeUnderlyingReceivedInvocations: [(isEncrypted: Bool, isOneToOne: Bool, mode: RoomNotificationMode)] = []
|
|
open var setDefaultRoomNotificationModeIsEncryptedIsOneToOneModeReceivedInvocations: [(isEncrypted: Bool, isOneToOne: Bool, mode: RoomNotificationMode)] {
|
|
get { setDefaultRoomNotificationModeIsEncryptedIsOneToOneModeReceivedInvocationsLock.withLock { setDefaultRoomNotificationModeIsEncryptedIsOneToOneModeUnderlyingReceivedInvocations } }
|
|
set { setDefaultRoomNotificationModeIsEncryptedIsOneToOneModeReceivedInvocationsLock.withLock { setDefaultRoomNotificationModeIsEncryptedIsOneToOneModeUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var setDefaultRoomNotificationModeIsEncryptedIsOneToOneModeClosure: ((Bool, Bool, RoomNotificationMode) async throws -> Void)?
|
|
|
|
open override func setDefaultRoomNotificationMode(isEncrypted: Bool, isOneToOne: Bool, mode: RoomNotificationMode) async throws {
|
|
if let error = setDefaultRoomNotificationModeIsEncryptedIsOneToOneModeThrowableError {
|
|
throw error
|
|
}
|
|
setDefaultRoomNotificationModeIsEncryptedIsOneToOneModeCallsCountLock.withLock { setDefaultRoomNotificationModeIsEncryptedIsOneToOneModeUnderlyingCallsCount += 1 }
|
|
setDefaultRoomNotificationModeIsEncryptedIsOneToOneModeReceivedArguments = (isEncrypted: isEncrypted, isOneToOne: isOneToOne, mode: mode)
|
|
setDefaultRoomNotificationModeIsEncryptedIsOneToOneModeReceivedInvocationsLock.withLock { setDefaultRoomNotificationModeIsEncryptedIsOneToOneModeUnderlyingReceivedInvocations.append((isEncrypted: isEncrypted, isOneToOne: isOneToOne, mode: mode)) }
|
|
try await setDefaultRoomNotificationModeIsEncryptedIsOneToOneModeClosure?(isEncrypted, isOneToOne, mode)
|
|
}
|
|
|
|
//MARK: - setDelegate
|
|
|
|
private let setDelegateDelegateCallsCountLock = NSLock()
|
|
private var setDelegateDelegateUnderlyingCallsCount = 0
|
|
open var setDelegateDelegateCallsCount: Int {
|
|
get { setDelegateDelegateCallsCountLock.withLock { setDelegateDelegateUnderlyingCallsCount } }
|
|
set { setDelegateDelegateCallsCountLock.withLock { setDelegateDelegateUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var setDelegateDelegateCalled: Bool {
|
|
return setDelegateDelegateCallsCount > 0
|
|
}
|
|
private let setDelegateDelegateReceivedDelegateLock = NSLock()
|
|
private var setDelegateDelegateUnderlyingReceivedDelegate: NotificationSettingsDelegate?
|
|
open var setDelegateDelegateReceivedDelegate: NotificationSettingsDelegate? {
|
|
get { setDelegateDelegateReceivedDelegateLock.withLock { setDelegateDelegateUnderlyingReceivedDelegate } }
|
|
set { setDelegateDelegateReceivedDelegateLock.withLock { setDelegateDelegateUnderlyingReceivedDelegate = newValue } }
|
|
}
|
|
private let setDelegateDelegateReceivedInvocationsLock = NSLock()
|
|
private var setDelegateDelegateUnderlyingReceivedInvocations: [NotificationSettingsDelegate?] = []
|
|
open var setDelegateDelegateReceivedInvocations: [NotificationSettingsDelegate?] {
|
|
get { setDelegateDelegateReceivedInvocationsLock.withLock { setDelegateDelegateUnderlyingReceivedInvocations } }
|
|
set { setDelegateDelegateReceivedInvocationsLock.withLock { setDelegateDelegateUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var setDelegateDelegateClosure: ((NotificationSettingsDelegate?) -> Void)?
|
|
|
|
open override func setDelegate(delegate: NotificationSettingsDelegate?) {
|
|
setDelegateDelegateCallsCountLock.withLock { setDelegateDelegateUnderlyingCallsCount += 1 }
|
|
setDelegateDelegateReceivedDelegate = delegate
|
|
setDelegateDelegateReceivedInvocationsLock.withLock { setDelegateDelegateUnderlyingReceivedInvocations.append(delegate) }
|
|
setDelegateDelegateClosure?(delegate)
|
|
}
|
|
|
|
//MARK: - setInviteForMeEnabled
|
|
|
|
open var setInviteForMeEnabledEnabledThrowableError: Error?
|
|
private let setInviteForMeEnabledEnabledCallsCountLock = NSLock()
|
|
private var setInviteForMeEnabledEnabledUnderlyingCallsCount = 0
|
|
open var setInviteForMeEnabledEnabledCallsCount: Int {
|
|
get { setInviteForMeEnabledEnabledCallsCountLock.withLock { setInviteForMeEnabledEnabledUnderlyingCallsCount } }
|
|
set { setInviteForMeEnabledEnabledCallsCountLock.withLock { setInviteForMeEnabledEnabledUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var setInviteForMeEnabledEnabledCalled: Bool {
|
|
return setInviteForMeEnabledEnabledCallsCount > 0
|
|
}
|
|
private let setInviteForMeEnabledEnabledReceivedEnabledLock = NSLock()
|
|
private var setInviteForMeEnabledEnabledUnderlyingReceivedEnabled: Bool?
|
|
open var setInviteForMeEnabledEnabledReceivedEnabled: Bool? {
|
|
get { setInviteForMeEnabledEnabledReceivedEnabledLock.withLock { setInviteForMeEnabledEnabledUnderlyingReceivedEnabled } }
|
|
set { setInviteForMeEnabledEnabledReceivedEnabledLock.withLock { setInviteForMeEnabledEnabledUnderlyingReceivedEnabled = newValue } }
|
|
}
|
|
private let setInviteForMeEnabledEnabledReceivedInvocationsLock = NSLock()
|
|
private var setInviteForMeEnabledEnabledUnderlyingReceivedInvocations: [Bool] = []
|
|
open var setInviteForMeEnabledEnabledReceivedInvocations: [Bool] {
|
|
get { setInviteForMeEnabledEnabledReceivedInvocationsLock.withLock { setInviteForMeEnabledEnabledUnderlyingReceivedInvocations } }
|
|
set { setInviteForMeEnabledEnabledReceivedInvocationsLock.withLock { setInviteForMeEnabledEnabledUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var setInviteForMeEnabledEnabledClosure: ((Bool) async throws -> Void)?
|
|
|
|
open override func setInviteForMeEnabled(enabled: Bool) async throws {
|
|
if let error = setInviteForMeEnabledEnabledThrowableError {
|
|
throw error
|
|
}
|
|
setInviteForMeEnabledEnabledCallsCountLock.withLock { setInviteForMeEnabledEnabledUnderlyingCallsCount += 1 }
|
|
setInviteForMeEnabledEnabledReceivedEnabled = enabled
|
|
setInviteForMeEnabledEnabledReceivedInvocationsLock.withLock { setInviteForMeEnabledEnabledUnderlyingReceivedInvocations.append(enabled) }
|
|
try await setInviteForMeEnabledEnabledClosure?(enabled)
|
|
}
|
|
|
|
//MARK: - setRoomMentionEnabled
|
|
|
|
open var setRoomMentionEnabledEnabledThrowableError: Error?
|
|
private let setRoomMentionEnabledEnabledCallsCountLock = NSLock()
|
|
private var setRoomMentionEnabledEnabledUnderlyingCallsCount = 0
|
|
open var setRoomMentionEnabledEnabledCallsCount: Int {
|
|
get { setRoomMentionEnabledEnabledCallsCountLock.withLock { setRoomMentionEnabledEnabledUnderlyingCallsCount } }
|
|
set { setRoomMentionEnabledEnabledCallsCountLock.withLock { setRoomMentionEnabledEnabledUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var setRoomMentionEnabledEnabledCalled: Bool {
|
|
return setRoomMentionEnabledEnabledCallsCount > 0
|
|
}
|
|
private let setRoomMentionEnabledEnabledReceivedEnabledLock = NSLock()
|
|
private var setRoomMentionEnabledEnabledUnderlyingReceivedEnabled: Bool?
|
|
open var setRoomMentionEnabledEnabledReceivedEnabled: Bool? {
|
|
get { setRoomMentionEnabledEnabledReceivedEnabledLock.withLock { setRoomMentionEnabledEnabledUnderlyingReceivedEnabled } }
|
|
set { setRoomMentionEnabledEnabledReceivedEnabledLock.withLock { setRoomMentionEnabledEnabledUnderlyingReceivedEnabled = newValue } }
|
|
}
|
|
private let setRoomMentionEnabledEnabledReceivedInvocationsLock = NSLock()
|
|
private var setRoomMentionEnabledEnabledUnderlyingReceivedInvocations: [Bool] = []
|
|
open var setRoomMentionEnabledEnabledReceivedInvocations: [Bool] {
|
|
get { setRoomMentionEnabledEnabledReceivedInvocationsLock.withLock { setRoomMentionEnabledEnabledUnderlyingReceivedInvocations } }
|
|
set { setRoomMentionEnabledEnabledReceivedInvocationsLock.withLock { setRoomMentionEnabledEnabledUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var setRoomMentionEnabledEnabledClosure: ((Bool) async throws -> Void)?
|
|
|
|
open override func setRoomMentionEnabled(enabled: Bool) async throws {
|
|
if let error = setRoomMentionEnabledEnabledThrowableError {
|
|
throw error
|
|
}
|
|
setRoomMentionEnabledEnabledCallsCountLock.withLock { setRoomMentionEnabledEnabledUnderlyingCallsCount += 1 }
|
|
setRoomMentionEnabledEnabledReceivedEnabled = enabled
|
|
setRoomMentionEnabledEnabledReceivedInvocationsLock.withLock { setRoomMentionEnabledEnabledUnderlyingReceivedInvocations.append(enabled) }
|
|
try await setRoomMentionEnabledEnabledClosure?(enabled)
|
|
}
|
|
|
|
//MARK: - setRoomNotificationMode
|
|
|
|
open var setRoomNotificationModeRoomIdModeThrowableError: Error?
|
|
private let setRoomNotificationModeRoomIdModeCallsCountLock = NSLock()
|
|
private var setRoomNotificationModeRoomIdModeUnderlyingCallsCount = 0
|
|
open var setRoomNotificationModeRoomIdModeCallsCount: Int {
|
|
get { setRoomNotificationModeRoomIdModeCallsCountLock.withLock { setRoomNotificationModeRoomIdModeUnderlyingCallsCount } }
|
|
set { setRoomNotificationModeRoomIdModeCallsCountLock.withLock { setRoomNotificationModeRoomIdModeUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var setRoomNotificationModeRoomIdModeCalled: Bool {
|
|
return setRoomNotificationModeRoomIdModeCallsCount > 0
|
|
}
|
|
private let setRoomNotificationModeRoomIdModeReceivedArgumentsLock = NSLock()
|
|
private var setRoomNotificationModeRoomIdModeUnderlyingReceivedArguments: (roomId: String, mode: RoomNotificationMode)?
|
|
open var setRoomNotificationModeRoomIdModeReceivedArguments: (roomId: String, mode: RoomNotificationMode)? {
|
|
get { setRoomNotificationModeRoomIdModeReceivedArgumentsLock.withLock { setRoomNotificationModeRoomIdModeUnderlyingReceivedArguments } }
|
|
set { setRoomNotificationModeRoomIdModeReceivedArgumentsLock.withLock { setRoomNotificationModeRoomIdModeUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let setRoomNotificationModeRoomIdModeReceivedInvocationsLock = NSLock()
|
|
private var setRoomNotificationModeRoomIdModeUnderlyingReceivedInvocations: [(roomId: String, mode: RoomNotificationMode)] = []
|
|
open var setRoomNotificationModeRoomIdModeReceivedInvocations: [(roomId: String, mode: RoomNotificationMode)] {
|
|
get { setRoomNotificationModeRoomIdModeReceivedInvocationsLock.withLock { setRoomNotificationModeRoomIdModeUnderlyingReceivedInvocations } }
|
|
set { setRoomNotificationModeRoomIdModeReceivedInvocationsLock.withLock { setRoomNotificationModeRoomIdModeUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var setRoomNotificationModeRoomIdModeClosure: ((String, RoomNotificationMode) async throws -> Void)?
|
|
|
|
open override func setRoomNotificationMode(roomId: String, mode: RoomNotificationMode) async throws {
|
|
if let error = setRoomNotificationModeRoomIdModeThrowableError {
|
|
throw error
|
|
}
|
|
setRoomNotificationModeRoomIdModeCallsCountLock.withLock { setRoomNotificationModeRoomIdModeUnderlyingCallsCount += 1 }
|
|
setRoomNotificationModeRoomIdModeReceivedArguments = (roomId: roomId, mode: mode)
|
|
setRoomNotificationModeRoomIdModeReceivedInvocationsLock.withLock { setRoomNotificationModeRoomIdModeUnderlyingReceivedInvocations.append((roomId: roomId, mode: mode)) }
|
|
try await setRoomNotificationModeRoomIdModeClosure?(roomId, mode)
|
|
}
|
|
|
|
//MARK: - setUserMentionEnabled
|
|
|
|
open var setUserMentionEnabledEnabledThrowableError: Error?
|
|
private let setUserMentionEnabledEnabledCallsCountLock = NSLock()
|
|
private var setUserMentionEnabledEnabledUnderlyingCallsCount = 0
|
|
open var setUserMentionEnabledEnabledCallsCount: Int {
|
|
get { setUserMentionEnabledEnabledCallsCountLock.withLock { setUserMentionEnabledEnabledUnderlyingCallsCount } }
|
|
set { setUserMentionEnabledEnabledCallsCountLock.withLock { setUserMentionEnabledEnabledUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var setUserMentionEnabledEnabledCalled: Bool {
|
|
return setUserMentionEnabledEnabledCallsCount > 0
|
|
}
|
|
private let setUserMentionEnabledEnabledReceivedEnabledLock = NSLock()
|
|
private var setUserMentionEnabledEnabledUnderlyingReceivedEnabled: Bool?
|
|
open var setUserMentionEnabledEnabledReceivedEnabled: Bool? {
|
|
get { setUserMentionEnabledEnabledReceivedEnabledLock.withLock { setUserMentionEnabledEnabledUnderlyingReceivedEnabled } }
|
|
set { setUserMentionEnabledEnabledReceivedEnabledLock.withLock { setUserMentionEnabledEnabledUnderlyingReceivedEnabled = newValue } }
|
|
}
|
|
private let setUserMentionEnabledEnabledReceivedInvocationsLock = NSLock()
|
|
private var setUserMentionEnabledEnabledUnderlyingReceivedInvocations: [Bool] = []
|
|
open var setUserMentionEnabledEnabledReceivedInvocations: [Bool] {
|
|
get { setUserMentionEnabledEnabledReceivedInvocationsLock.withLock { setUserMentionEnabledEnabledUnderlyingReceivedInvocations } }
|
|
set { setUserMentionEnabledEnabledReceivedInvocationsLock.withLock { setUserMentionEnabledEnabledUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var setUserMentionEnabledEnabledClosure: ((Bool) async throws -> Void)?
|
|
|
|
open override func setUserMentionEnabled(enabled: Bool) async throws {
|
|
if let error = setUserMentionEnabledEnabledThrowableError {
|
|
throw error
|
|
}
|
|
setUserMentionEnabledEnabledCallsCountLock.withLock { setUserMentionEnabledEnabledUnderlyingCallsCount += 1 }
|
|
setUserMentionEnabledEnabledReceivedEnabled = enabled
|
|
setUserMentionEnabledEnabledReceivedInvocationsLock.withLock { setUserMentionEnabledEnabledUnderlyingReceivedInvocations.append(enabled) }
|
|
try await setUserMentionEnabledEnabledClosure?(enabled)
|
|
}
|
|
|
|
//MARK: - unmuteRoom
|
|
|
|
open var unmuteRoomRoomIdIsEncryptedIsOneToOneThrowableError: Error?
|
|
private let unmuteRoomRoomIdIsEncryptedIsOneToOneCallsCountLock = NSLock()
|
|
private var unmuteRoomRoomIdIsEncryptedIsOneToOneUnderlyingCallsCount = 0
|
|
open var unmuteRoomRoomIdIsEncryptedIsOneToOneCallsCount: Int {
|
|
get { unmuteRoomRoomIdIsEncryptedIsOneToOneCallsCountLock.withLock { unmuteRoomRoomIdIsEncryptedIsOneToOneUnderlyingCallsCount } }
|
|
set { unmuteRoomRoomIdIsEncryptedIsOneToOneCallsCountLock.withLock { unmuteRoomRoomIdIsEncryptedIsOneToOneUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var unmuteRoomRoomIdIsEncryptedIsOneToOneCalled: Bool {
|
|
return unmuteRoomRoomIdIsEncryptedIsOneToOneCallsCount > 0
|
|
}
|
|
private let unmuteRoomRoomIdIsEncryptedIsOneToOneReceivedArgumentsLock = NSLock()
|
|
private var unmuteRoomRoomIdIsEncryptedIsOneToOneUnderlyingReceivedArguments: (roomId: String, isEncrypted: Bool, isOneToOne: Bool)?
|
|
open var unmuteRoomRoomIdIsEncryptedIsOneToOneReceivedArguments: (roomId: String, isEncrypted: Bool, isOneToOne: Bool)? {
|
|
get { unmuteRoomRoomIdIsEncryptedIsOneToOneReceivedArgumentsLock.withLock { unmuteRoomRoomIdIsEncryptedIsOneToOneUnderlyingReceivedArguments } }
|
|
set { unmuteRoomRoomIdIsEncryptedIsOneToOneReceivedArgumentsLock.withLock { unmuteRoomRoomIdIsEncryptedIsOneToOneUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let unmuteRoomRoomIdIsEncryptedIsOneToOneReceivedInvocationsLock = NSLock()
|
|
private var unmuteRoomRoomIdIsEncryptedIsOneToOneUnderlyingReceivedInvocations: [(roomId: String, isEncrypted: Bool, isOneToOne: Bool)] = []
|
|
open var unmuteRoomRoomIdIsEncryptedIsOneToOneReceivedInvocations: [(roomId: String, isEncrypted: Bool, isOneToOne: Bool)] {
|
|
get { unmuteRoomRoomIdIsEncryptedIsOneToOneReceivedInvocationsLock.withLock { unmuteRoomRoomIdIsEncryptedIsOneToOneUnderlyingReceivedInvocations } }
|
|
set { unmuteRoomRoomIdIsEncryptedIsOneToOneReceivedInvocationsLock.withLock { unmuteRoomRoomIdIsEncryptedIsOneToOneUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var unmuteRoomRoomIdIsEncryptedIsOneToOneClosure: ((String, Bool, Bool) async throws -> Void)?
|
|
|
|
open override func unmuteRoom(roomId: String, isEncrypted: Bool, isOneToOne: Bool) async throws {
|
|
if let error = unmuteRoomRoomIdIsEncryptedIsOneToOneThrowableError {
|
|
throw error
|
|
}
|
|
unmuteRoomRoomIdIsEncryptedIsOneToOneCallsCountLock.withLock { unmuteRoomRoomIdIsEncryptedIsOneToOneUnderlyingCallsCount += 1 }
|
|
unmuteRoomRoomIdIsEncryptedIsOneToOneReceivedArguments = (roomId: roomId, isEncrypted: isEncrypted, isOneToOne: isOneToOne)
|
|
unmuteRoomRoomIdIsEncryptedIsOneToOneReceivedInvocationsLock.withLock { unmuteRoomRoomIdIsEncryptedIsOneToOneUnderlyingReceivedInvocations.append((roomId: roomId, isEncrypted: isEncrypted, isOneToOne: isOneToOne)) }
|
|
try await unmuteRoomRoomIdIsEncryptedIsOneToOneClosure?(roomId, isEncrypted, isOneToOne)
|
|
}
|
|
}
|
|
open class OAuthAuthorizationDataSDKMock: MatrixRustSDK.OAuthAuthorizationData, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
|
|
//MARK: - loginUrl
|
|
|
|
private let loginUrlCallsCountLock = NSLock()
|
|
private var loginUrlUnderlyingCallsCount = 0
|
|
open var loginUrlCallsCount: Int {
|
|
get { loginUrlCallsCountLock.withLock { loginUrlUnderlyingCallsCount } }
|
|
set { loginUrlCallsCountLock.withLock { loginUrlUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var loginUrlCalled: Bool {
|
|
return loginUrlCallsCount > 0
|
|
}
|
|
|
|
private let loginUrlReturnValueLock = NSLock()
|
|
open var loginUrlUnderlyingReturnValue: String!
|
|
open var loginUrlReturnValue: String! {
|
|
get { loginUrlReturnValueLock.withLock { loginUrlUnderlyingReturnValue } }
|
|
set { loginUrlReturnValueLock.withLock { loginUrlUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var loginUrlClosure: (() -> String)?
|
|
|
|
open override func loginUrl() -> String {
|
|
loginUrlCallsCountLock.withLock { loginUrlUnderlyingCallsCount += 1 }
|
|
if let loginUrlClosure = loginUrlClosure {
|
|
return loginUrlClosure()
|
|
} else {
|
|
return loginUrlReturnValue
|
|
}
|
|
}
|
|
}
|
|
open class PrivateStringSDKMock: MatrixRustSDK.PrivateString, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
}
|
|
open class QrCodeDataSDKMock: MatrixRustSDK.QrCodeData, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
static func reset()
|
|
{
|
|
}
|
|
|
|
//MARK: - baseUrl
|
|
|
|
private let baseUrlCallsCountLock = NSLock()
|
|
private var baseUrlUnderlyingCallsCount = 0
|
|
open var baseUrlCallsCount: Int {
|
|
get { baseUrlCallsCountLock.withLock { baseUrlUnderlyingCallsCount } }
|
|
set { baseUrlCallsCountLock.withLock { baseUrlUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var baseUrlCalled: Bool {
|
|
return baseUrlCallsCount > 0
|
|
}
|
|
|
|
private let baseUrlReturnValueLock = NSLock()
|
|
open var baseUrlUnderlyingReturnValue: String?
|
|
open var baseUrlReturnValue: String? {
|
|
get { baseUrlReturnValueLock.withLock { baseUrlUnderlyingReturnValue } }
|
|
set { baseUrlReturnValueLock.withLock { baseUrlUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var baseUrlClosure: (() -> String?)?
|
|
|
|
open override func baseUrl() -> String? {
|
|
baseUrlCallsCountLock.withLock { baseUrlUnderlyingCallsCount += 1 }
|
|
if let baseUrlClosure = baseUrlClosure {
|
|
return baseUrlClosure()
|
|
} else {
|
|
return baseUrlReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - intent
|
|
|
|
private let intentCallsCountLock = NSLock()
|
|
private var intentUnderlyingCallsCount = 0
|
|
open var intentCallsCount: Int {
|
|
get { intentCallsCountLock.withLock { intentUnderlyingCallsCount } }
|
|
set { intentCallsCountLock.withLock { intentUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var intentCalled: Bool {
|
|
return intentCallsCount > 0
|
|
}
|
|
|
|
private let intentReturnValueLock = NSLock()
|
|
open var intentUnderlyingReturnValue: QrCodeIntent!
|
|
open var intentReturnValue: QrCodeIntent! {
|
|
get { intentReturnValueLock.withLock { intentUnderlyingReturnValue } }
|
|
set { intentReturnValueLock.withLock { intentUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var intentClosure: (() -> QrCodeIntent)?
|
|
|
|
open override func intent() -> QrCodeIntent {
|
|
intentCallsCountLock.withLock { intentUnderlyingCallsCount += 1 }
|
|
if let intentClosure = intentClosure {
|
|
return intentClosure()
|
|
} else {
|
|
return intentReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - serverName
|
|
|
|
private let serverNameCallsCountLock = NSLock()
|
|
private var serverNameUnderlyingCallsCount = 0
|
|
open var serverNameCallsCount: Int {
|
|
get { serverNameCallsCountLock.withLock { serverNameUnderlyingCallsCount } }
|
|
set { serverNameCallsCountLock.withLock { serverNameUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var serverNameCalled: Bool {
|
|
return serverNameCallsCount > 0
|
|
}
|
|
|
|
private let serverNameReturnValueLock = NSLock()
|
|
open var serverNameUnderlyingReturnValue: String?
|
|
open var serverNameReturnValue: String? {
|
|
get { serverNameReturnValueLock.withLock { serverNameUnderlyingReturnValue } }
|
|
set { serverNameReturnValueLock.withLock { serverNameUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var serverNameClosure: (() -> String?)?
|
|
|
|
open override func serverName() -> String? {
|
|
serverNameCallsCountLock.withLock { serverNameUnderlyingCallsCount += 1 }
|
|
if let serverNameClosure = serverNameClosure {
|
|
return serverNameClosure()
|
|
} else {
|
|
return serverNameReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - toBytes
|
|
|
|
private let toBytesCallsCountLock = NSLock()
|
|
private var toBytesUnderlyingCallsCount = 0
|
|
open var toBytesCallsCount: Int {
|
|
get { toBytesCallsCountLock.withLock { toBytesUnderlyingCallsCount } }
|
|
set { toBytesCallsCountLock.withLock { toBytesUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var toBytesCalled: Bool {
|
|
return toBytesCallsCount > 0
|
|
}
|
|
|
|
private let toBytesReturnValueLock = NSLock()
|
|
open var toBytesUnderlyingReturnValue: Data!
|
|
open var toBytesReturnValue: Data! {
|
|
get { toBytesReturnValueLock.withLock { toBytesUnderlyingReturnValue } }
|
|
set { toBytesReturnValueLock.withLock { toBytesUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var toBytesClosure: (() -> Data)?
|
|
|
|
open override func toBytes() -> Data {
|
|
toBytesCallsCountLock.withLock { toBytesUnderlyingCallsCount += 1 }
|
|
if let toBytesClosure = toBytesClosure {
|
|
return toBytesClosure()
|
|
} else {
|
|
return toBytesReturnValue
|
|
}
|
|
}
|
|
}
|
|
open class RoomSDKMock: MatrixRustSDK.Room, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
|
|
//MARK: - activeMembersCount
|
|
|
|
private let activeMembersCountCallsCountLock = NSLock()
|
|
private var activeMembersCountUnderlyingCallsCount = 0
|
|
open var activeMembersCountCallsCount: Int {
|
|
get { activeMembersCountCallsCountLock.withLock { activeMembersCountUnderlyingCallsCount } }
|
|
set { activeMembersCountCallsCountLock.withLock { activeMembersCountUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var activeMembersCountCalled: Bool {
|
|
return activeMembersCountCallsCount > 0
|
|
}
|
|
|
|
private let activeMembersCountReturnValueLock = NSLock()
|
|
open var activeMembersCountUnderlyingReturnValue: UInt64!
|
|
open var activeMembersCountReturnValue: UInt64! {
|
|
get { activeMembersCountReturnValueLock.withLock { activeMembersCountUnderlyingReturnValue } }
|
|
set { activeMembersCountReturnValueLock.withLock { activeMembersCountUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var activeMembersCountClosure: (() -> UInt64)?
|
|
|
|
open override func activeMembersCount() -> UInt64 {
|
|
activeMembersCountCallsCountLock.withLock { activeMembersCountUnderlyingCallsCount += 1 }
|
|
if let activeMembersCountClosure = activeMembersCountClosure {
|
|
return activeMembersCountClosure()
|
|
} else {
|
|
return activeMembersCountReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - activeRoomCallParticipants
|
|
|
|
private let activeRoomCallParticipantsCallsCountLock = NSLock()
|
|
private var activeRoomCallParticipantsUnderlyingCallsCount = 0
|
|
open var activeRoomCallParticipantsCallsCount: Int {
|
|
get { activeRoomCallParticipantsCallsCountLock.withLock { activeRoomCallParticipantsUnderlyingCallsCount } }
|
|
set { activeRoomCallParticipantsCallsCountLock.withLock { activeRoomCallParticipantsUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var activeRoomCallParticipantsCalled: Bool {
|
|
return activeRoomCallParticipantsCallsCount > 0
|
|
}
|
|
|
|
private let activeRoomCallParticipantsReturnValueLock = NSLock()
|
|
open var activeRoomCallParticipantsUnderlyingReturnValue: [String]!
|
|
open var activeRoomCallParticipantsReturnValue: [String]! {
|
|
get { activeRoomCallParticipantsReturnValueLock.withLock { activeRoomCallParticipantsUnderlyingReturnValue } }
|
|
set { activeRoomCallParticipantsReturnValueLock.withLock { activeRoomCallParticipantsUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var activeRoomCallParticipantsClosure: (() -> [String])?
|
|
|
|
open override func activeRoomCallParticipants() -> [String] {
|
|
activeRoomCallParticipantsCallsCountLock.withLock { activeRoomCallParticipantsUnderlyingCallsCount += 1 }
|
|
if let activeRoomCallParticipantsClosure = activeRoomCallParticipantsClosure {
|
|
return activeRoomCallParticipantsClosure()
|
|
} else {
|
|
return activeRoomCallParticipantsReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - alternativeAliases
|
|
|
|
private let alternativeAliasesCallsCountLock = NSLock()
|
|
private var alternativeAliasesUnderlyingCallsCount = 0
|
|
open var alternativeAliasesCallsCount: Int {
|
|
get { alternativeAliasesCallsCountLock.withLock { alternativeAliasesUnderlyingCallsCount } }
|
|
set { alternativeAliasesCallsCountLock.withLock { alternativeAliasesUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var alternativeAliasesCalled: Bool {
|
|
return alternativeAliasesCallsCount > 0
|
|
}
|
|
|
|
private let alternativeAliasesReturnValueLock = NSLock()
|
|
open var alternativeAliasesUnderlyingReturnValue: [String]!
|
|
open var alternativeAliasesReturnValue: [String]! {
|
|
get { alternativeAliasesReturnValueLock.withLock { alternativeAliasesUnderlyingReturnValue } }
|
|
set { alternativeAliasesReturnValueLock.withLock { alternativeAliasesUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var alternativeAliasesClosure: (() -> [String])?
|
|
|
|
open override func alternativeAliases() -> [String] {
|
|
alternativeAliasesCallsCountLock.withLock { alternativeAliasesUnderlyingCallsCount += 1 }
|
|
if let alternativeAliasesClosure = alternativeAliasesClosure {
|
|
return alternativeAliasesClosure()
|
|
} else {
|
|
return alternativeAliasesReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - applyPowerLevelChanges
|
|
|
|
open var applyPowerLevelChangesChangesThrowableError: Error?
|
|
private let applyPowerLevelChangesChangesCallsCountLock = NSLock()
|
|
private var applyPowerLevelChangesChangesUnderlyingCallsCount = 0
|
|
open var applyPowerLevelChangesChangesCallsCount: Int {
|
|
get { applyPowerLevelChangesChangesCallsCountLock.withLock { applyPowerLevelChangesChangesUnderlyingCallsCount } }
|
|
set { applyPowerLevelChangesChangesCallsCountLock.withLock { applyPowerLevelChangesChangesUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var applyPowerLevelChangesChangesCalled: Bool {
|
|
return applyPowerLevelChangesChangesCallsCount > 0
|
|
}
|
|
private let applyPowerLevelChangesChangesReceivedChangesLock = NSLock()
|
|
private var applyPowerLevelChangesChangesUnderlyingReceivedChanges: RoomPowerLevelChanges?
|
|
open var applyPowerLevelChangesChangesReceivedChanges: RoomPowerLevelChanges? {
|
|
get { applyPowerLevelChangesChangesReceivedChangesLock.withLock { applyPowerLevelChangesChangesUnderlyingReceivedChanges } }
|
|
set { applyPowerLevelChangesChangesReceivedChangesLock.withLock { applyPowerLevelChangesChangesUnderlyingReceivedChanges = newValue } }
|
|
}
|
|
private let applyPowerLevelChangesChangesReceivedInvocationsLock = NSLock()
|
|
private var applyPowerLevelChangesChangesUnderlyingReceivedInvocations: [RoomPowerLevelChanges] = []
|
|
open var applyPowerLevelChangesChangesReceivedInvocations: [RoomPowerLevelChanges] {
|
|
get { applyPowerLevelChangesChangesReceivedInvocationsLock.withLock { applyPowerLevelChangesChangesUnderlyingReceivedInvocations } }
|
|
set { applyPowerLevelChangesChangesReceivedInvocationsLock.withLock { applyPowerLevelChangesChangesUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var applyPowerLevelChangesChangesClosure: ((RoomPowerLevelChanges) async throws -> Void)?
|
|
|
|
open override func applyPowerLevelChanges(changes: RoomPowerLevelChanges) async throws {
|
|
if let error = applyPowerLevelChangesChangesThrowableError {
|
|
throw error
|
|
}
|
|
applyPowerLevelChangesChangesCallsCountLock.withLock { applyPowerLevelChangesChangesUnderlyingCallsCount += 1 }
|
|
applyPowerLevelChangesChangesReceivedChanges = changes
|
|
applyPowerLevelChangesChangesReceivedInvocationsLock.withLock { applyPowerLevelChangesChangesUnderlyingReceivedInvocations.append(changes) }
|
|
try await applyPowerLevelChangesChangesClosure?(changes)
|
|
}
|
|
|
|
//MARK: - avatarUrl
|
|
|
|
private let avatarUrlCallsCountLock = NSLock()
|
|
private var avatarUrlUnderlyingCallsCount = 0
|
|
open var avatarUrlCallsCount: Int {
|
|
get { avatarUrlCallsCountLock.withLock { avatarUrlUnderlyingCallsCount } }
|
|
set { avatarUrlCallsCountLock.withLock { avatarUrlUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var avatarUrlCalled: Bool {
|
|
return avatarUrlCallsCount > 0
|
|
}
|
|
|
|
private let avatarUrlReturnValueLock = NSLock()
|
|
open var avatarUrlUnderlyingReturnValue: String?
|
|
open var avatarUrlReturnValue: String? {
|
|
get { avatarUrlReturnValueLock.withLock { avatarUrlUnderlyingReturnValue } }
|
|
set { avatarUrlReturnValueLock.withLock { avatarUrlUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var avatarUrlClosure: (() -> String?)?
|
|
|
|
open override func avatarUrl() -> String? {
|
|
avatarUrlCallsCountLock.withLock { avatarUrlUnderlyingCallsCount += 1 }
|
|
if let avatarUrlClosure = avatarUrlClosure {
|
|
return avatarUrlClosure()
|
|
} else {
|
|
return avatarUrlReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - banUser
|
|
|
|
open var banUserUserIdReasonThrowableError: Error?
|
|
private let banUserUserIdReasonCallsCountLock = NSLock()
|
|
private var banUserUserIdReasonUnderlyingCallsCount = 0
|
|
open var banUserUserIdReasonCallsCount: Int {
|
|
get { banUserUserIdReasonCallsCountLock.withLock { banUserUserIdReasonUnderlyingCallsCount } }
|
|
set { banUserUserIdReasonCallsCountLock.withLock { banUserUserIdReasonUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var banUserUserIdReasonCalled: Bool {
|
|
return banUserUserIdReasonCallsCount > 0
|
|
}
|
|
private let banUserUserIdReasonReceivedArgumentsLock = NSLock()
|
|
private var banUserUserIdReasonUnderlyingReceivedArguments: (userId: String, reason: String?)?
|
|
open var banUserUserIdReasonReceivedArguments: (userId: String, reason: String?)? {
|
|
get { banUserUserIdReasonReceivedArgumentsLock.withLock { banUserUserIdReasonUnderlyingReceivedArguments } }
|
|
set { banUserUserIdReasonReceivedArgumentsLock.withLock { banUserUserIdReasonUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let banUserUserIdReasonReceivedInvocationsLock = NSLock()
|
|
private var banUserUserIdReasonUnderlyingReceivedInvocations: [(userId: String, reason: String?)] = []
|
|
open var banUserUserIdReasonReceivedInvocations: [(userId: String, reason: String?)] {
|
|
get { banUserUserIdReasonReceivedInvocationsLock.withLock { banUserUserIdReasonUnderlyingReceivedInvocations } }
|
|
set { banUserUserIdReasonReceivedInvocationsLock.withLock { banUserUserIdReasonUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var banUserUserIdReasonClosure: ((String, String?) async throws -> Void)?
|
|
|
|
open override func banUser(userId: String, reason: String?) async throws {
|
|
if let error = banUserUserIdReasonThrowableError {
|
|
throw error
|
|
}
|
|
banUserUserIdReasonCallsCountLock.withLock { banUserUserIdReasonUnderlyingCallsCount += 1 }
|
|
banUserUserIdReasonReceivedArguments = (userId: userId, reason: reason)
|
|
banUserUserIdReasonReceivedInvocationsLock.withLock { banUserUserIdReasonUnderlyingReceivedInvocations.append((userId: userId, reason: reason)) }
|
|
try await banUserUserIdReasonClosure?(userId, reason)
|
|
}
|
|
|
|
//MARK: - canonicalAlias
|
|
|
|
private let canonicalAliasCallsCountLock = NSLock()
|
|
private var canonicalAliasUnderlyingCallsCount = 0
|
|
open var canonicalAliasCallsCount: Int {
|
|
get { canonicalAliasCallsCountLock.withLock { canonicalAliasUnderlyingCallsCount } }
|
|
set { canonicalAliasCallsCountLock.withLock { canonicalAliasUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var canonicalAliasCalled: Bool {
|
|
return canonicalAliasCallsCount > 0
|
|
}
|
|
|
|
private let canonicalAliasReturnValueLock = NSLock()
|
|
open var canonicalAliasUnderlyingReturnValue: String?
|
|
open var canonicalAliasReturnValue: String? {
|
|
get { canonicalAliasReturnValueLock.withLock { canonicalAliasUnderlyingReturnValue } }
|
|
set { canonicalAliasReturnValueLock.withLock { canonicalAliasUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var canonicalAliasClosure: (() -> String?)?
|
|
|
|
open override func canonicalAlias() -> String? {
|
|
canonicalAliasCallsCountLock.withLock { canonicalAliasUnderlyingCallsCount += 1 }
|
|
if let canonicalAliasClosure = canonicalAliasClosure {
|
|
return canonicalAliasClosure()
|
|
} else {
|
|
return canonicalAliasReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - clearComposerDraft
|
|
|
|
open var clearComposerDraftThreadRootThrowableError: Error?
|
|
private let clearComposerDraftThreadRootCallsCountLock = NSLock()
|
|
private var clearComposerDraftThreadRootUnderlyingCallsCount = 0
|
|
open var clearComposerDraftThreadRootCallsCount: Int {
|
|
get { clearComposerDraftThreadRootCallsCountLock.withLock { clearComposerDraftThreadRootUnderlyingCallsCount } }
|
|
set { clearComposerDraftThreadRootCallsCountLock.withLock { clearComposerDraftThreadRootUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var clearComposerDraftThreadRootCalled: Bool {
|
|
return clearComposerDraftThreadRootCallsCount > 0
|
|
}
|
|
private let clearComposerDraftThreadRootReceivedThreadRootLock = NSLock()
|
|
private var clearComposerDraftThreadRootUnderlyingReceivedThreadRoot: String?
|
|
open var clearComposerDraftThreadRootReceivedThreadRoot: String? {
|
|
get { clearComposerDraftThreadRootReceivedThreadRootLock.withLock { clearComposerDraftThreadRootUnderlyingReceivedThreadRoot } }
|
|
set { clearComposerDraftThreadRootReceivedThreadRootLock.withLock { clearComposerDraftThreadRootUnderlyingReceivedThreadRoot = newValue } }
|
|
}
|
|
private let clearComposerDraftThreadRootReceivedInvocationsLock = NSLock()
|
|
private var clearComposerDraftThreadRootUnderlyingReceivedInvocations: [String?] = []
|
|
open var clearComposerDraftThreadRootReceivedInvocations: [String?] {
|
|
get { clearComposerDraftThreadRootReceivedInvocationsLock.withLock { clearComposerDraftThreadRootUnderlyingReceivedInvocations } }
|
|
set { clearComposerDraftThreadRootReceivedInvocationsLock.withLock { clearComposerDraftThreadRootUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var clearComposerDraftThreadRootClosure: ((String?) async throws -> Void)?
|
|
|
|
open override func clearComposerDraft(threadRoot: String?) async throws {
|
|
if let error = clearComposerDraftThreadRootThrowableError {
|
|
throw error
|
|
}
|
|
clearComposerDraftThreadRootCallsCountLock.withLock { clearComposerDraftThreadRootUnderlyingCallsCount += 1 }
|
|
clearComposerDraftThreadRootReceivedThreadRoot = threadRoot
|
|
clearComposerDraftThreadRootReceivedInvocationsLock.withLock { clearComposerDraftThreadRootUnderlyingReceivedInvocations.append(threadRoot) }
|
|
try await clearComposerDraftThreadRootClosure?(threadRoot)
|
|
}
|
|
|
|
//MARK: - declineCall
|
|
|
|
open var declineCallRtcNotificationEventIdThrowableError: Error?
|
|
private let declineCallRtcNotificationEventIdCallsCountLock = NSLock()
|
|
private var declineCallRtcNotificationEventIdUnderlyingCallsCount = 0
|
|
open var declineCallRtcNotificationEventIdCallsCount: Int {
|
|
get { declineCallRtcNotificationEventIdCallsCountLock.withLock { declineCallRtcNotificationEventIdUnderlyingCallsCount } }
|
|
set { declineCallRtcNotificationEventIdCallsCountLock.withLock { declineCallRtcNotificationEventIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var declineCallRtcNotificationEventIdCalled: Bool {
|
|
return declineCallRtcNotificationEventIdCallsCount > 0
|
|
}
|
|
private let declineCallRtcNotificationEventIdReceivedRtcNotificationEventIdLock = NSLock()
|
|
private var declineCallRtcNotificationEventIdUnderlyingReceivedRtcNotificationEventId: String?
|
|
open var declineCallRtcNotificationEventIdReceivedRtcNotificationEventId: String? {
|
|
get { declineCallRtcNotificationEventIdReceivedRtcNotificationEventIdLock.withLock { declineCallRtcNotificationEventIdUnderlyingReceivedRtcNotificationEventId } }
|
|
set { declineCallRtcNotificationEventIdReceivedRtcNotificationEventIdLock.withLock { declineCallRtcNotificationEventIdUnderlyingReceivedRtcNotificationEventId = newValue } }
|
|
}
|
|
private let declineCallRtcNotificationEventIdReceivedInvocationsLock = NSLock()
|
|
private var declineCallRtcNotificationEventIdUnderlyingReceivedInvocations: [String] = []
|
|
open var declineCallRtcNotificationEventIdReceivedInvocations: [String] {
|
|
get { declineCallRtcNotificationEventIdReceivedInvocationsLock.withLock { declineCallRtcNotificationEventIdUnderlyingReceivedInvocations } }
|
|
set { declineCallRtcNotificationEventIdReceivedInvocationsLock.withLock { declineCallRtcNotificationEventIdUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var declineCallRtcNotificationEventIdClosure: ((String) async throws -> Void)?
|
|
|
|
open override func declineCall(rtcNotificationEventId: String) async throws {
|
|
if let error = declineCallRtcNotificationEventIdThrowableError {
|
|
throw error
|
|
}
|
|
declineCallRtcNotificationEventIdCallsCountLock.withLock { declineCallRtcNotificationEventIdUnderlyingCallsCount += 1 }
|
|
declineCallRtcNotificationEventIdReceivedRtcNotificationEventId = rtcNotificationEventId
|
|
declineCallRtcNotificationEventIdReceivedInvocationsLock.withLock { declineCallRtcNotificationEventIdUnderlyingReceivedInvocations.append(rtcNotificationEventId) }
|
|
try await declineCallRtcNotificationEventIdClosure?(rtcNotificationEventId)
|
|
}
|
|
|
|
//MARK: - discardRoomKey
|
|
|
|
open var discardRoomKeyThrowableError: Error?
|
|
private let discardRoomKeyCallsCountLock = NSLock()
|
|
private var discardRoomKeyUnderlyingCallsCount = 0
|
|
open var discardRoomKeyCallsCount: Int {
|
|
get { discardRoomKeyCallsCountLock.withLock { discardRoomKeyUnderlyingCallsCount } }
|
|
set { discardRoomKeyCallsCountLock.withLock { discardRoomKeyUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var discardRoomKeyCalled: Bool {
|
|
return discardRoomKeyCallsCount > 0
|
|
}
|
|
open var discardRoomKeyClosure: (() async throws -> Void)?
|
|
|
|
open override func discardRoomKey() async throws {
|
|
if let error = discardRoomKeyThrowableError {
|
|
throw error
|
|
}
|
|
discardRoomKeyCallsCountLock.withLock { discardRoomKeyUnderlyingCallsCount += 1 }
|
|
try await discardRoomKeyClosure?()
|
|
}
|
|
|
|
//MARK: - displayName
|
|
|
|
private let displayNameCallsCountLock = NSLock()
|
|
private var displayNameUnderlyingCallsCount = 0
|
|
open var displayNameCallsCount: Int {
|
|
get { displayNameCallsCountLock.withLock { displayNameUnderlyingCallsCount } }
|
|
set { displayNameCallsCountLock.withLock { displayNameUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var displayNameCalled: Bool {
|
|
return displayNameCallsCount > 0
|
|
}
|
|
|
|
private let displayNameReturnValueLock = NSLock()
|
|
open var displayNameUnderlyingReturnValue: String?
|
|
open var displayNameReturnValue: String? {
|
|
get { displayNameReturnValueLock.withLock { displayNameUnderlyingReturnValue } }
|
|
set { displayNameReturnValueLock.withLock { displayNameUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var displayNameClosure: (() -> String?)?
|
|
|
|
open override func displayName() -> String? {
|
|
displayNameCallsCountLock.withLock { displayNameUnderlyingCallsCount += 1 }
|
|
if let displayNameClosure = displayNameClosure {
|
|
return displayNameClosure()
|
|
} else {
|
|
return displayNameReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - edit
|
|
|
|
open var editEventIdNewContentThrowableError: Error?
|
|
private let editEventIdNewContentCallsCountLock = NSLock()
|
|
private var editEventIdNewContentUnderlyingCallsCount = 0
|
|
open var editEventIdNewContentCallsCount: Int {
|
|
get { editEventIdNewContentCallsCountLock.withLock { editEventIdNewContentUnderlyingCallsCount } }
|
|
set { editEventIdNewContentCallsCountLock.withLock { editEventIdNewContentUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var editEventIdNewContentCalled: Bool {
|
|
return editEventIdNewContentCallsCount > 0
|
|
}
|
|
private let editEventIdNewContentReceivedArgumentsLock = NSLock()
|
|
private var editEventIdNewContentUnderlyingReceivedArguments: (eventId: String, newContent: RoomMessageEventContentWithoutRelation)?
|
|
open var editEventIdNewContentReceivedArguments: (eventId: String, newContent: RoomMessageEventContentWithoutRelation)? {
|
|
get { editEventIdNewContentReceivedArgumentsLock.withLock { editEventIdNewContentUnderlyingReceivedArguments } }
|
|
set { editEventIdNewContentReceivedArgumentsLock.withLock { editEventIdNewContentUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let editEventIdNewContentReceivedInvocationsLock = NSLock()
|
|
private var editEventIdNewContentUnderlyingReceivedInvocations: [(eventId: String, newContent: RoomMessageEventContentWithoutRelation)] = []
|
|
open var editEventIdNewContentReceivedInvocations: [(eventId: String, newContent: RoomMessageEventContentWithoutRelation)] {
|
|
get { editEventIdNewContentReceivedInvocationsLock.withLock { editEventIdNewContentUnderlyingReceivedInvocations } }
|
|
set { editEventIdNewContentReceivedInvocationsLock.withLock { editEventIdNewContentUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var editEventIdNewContentClosure: ((String, RoomMessageEventContentWithoutRelation) async throws -> Void)?
|
|
|
|
open override func edit(eventId: String, newContent: RoomMessageEventContentWithoutRelation) async throws {
|
|
if let error = editEventIdNewContentThrowableError {
|
|
throw error
|
|
}
|
|
editEventIdNewContentCallsCountLock.withLock { editEventIdNewContentUnderlyingCallsCount += 1 }
|
|
editEventIdNewContentReceivedArguments = (eventId: eventId, newContent: newContent)
|
|
editEventIdNewContentReceivedInvocationsLock.withLock { editEventIdNewContentUnderlyingReceivedInvocations.append((eventId: eventId, newContent: newContent)) }
|
|
try await editEventIdNewContentClosure?(eventId, newContent)
|
|
}
|
|
|
|
//MARK: - enableEncryption
|
|
|
|
open var enableEncryptionThrowableError: Error?
|
|
private let enableEncryptionCallsCountLock = NSLock()
|
|
private var enableEncryptionUnderlyingCallsCount = 0
|
|
open var enableEncryptionCallsCount: Int {
|
|
get { enableEncryptionCallsCountLock.withLock { enableEncryptionUnderlyingCallsCount } }
|
|
set { enableEncryptionCallsCountLock.withLock { enableEncryptionUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var enableEncryptionCalled: Bool {
|
|
return enableEncryptionCallsCount > 0
|
|
}
|
|
open var enableEncryptionClosure: (() async throws -> Void)?
|
|
|
|
open override func enableEncryption() async throws {
|
|
if let error = enableEncryptionThrowableError {
|
|
throw error
|
|
}
|
|
enableEncryptionCallsCountLock.withLock { enableEncryptionUnderlyingCallsCount += 1 }
|
|
try await enableEncryptionClosure?()
|
|
}
|
|
|
|
//MARK: - enableSendQueue
|
|
|
|
private let enableSendQueueEnableCallsCountLock = NSLock()
|
|
private var enableSendQueueEnableUnderlyingCallsCount = 0
|
|
open var enableSendQueueEnableCallsCount: Int {
|
|
get { enableSendQueueEnableCallsCountLock.withLock { enableSendQueueEnableUnderlyingCallsCount } }
|
|
set { enableSendQueueEnableCallsCountLock.withLock { enableSendQueueEnableUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var enableSendQueueEnableCalled: Bool {
|
|
return enableSendQueueEnableCallsCount > 0
|
|
}
|
|
private let enableSendQueueEnableReceivedEnableLock = NSLock()
|
|
private var enableSendQueueEnableUnderlyingReceivedEnable: Bool?
|
|
open var enableSendQueueEnableReceivedEnable: Bool? {
|
|
get { enableSendQueueEnableReceivedEnableLock.withLock { enableSendQueueEnableUnderlyingReceivedEnable } }
|
|
set { enableSendQueueEnableReceivedEnableLock.withLock { enableSendQueueEnableUnderlyingReceivedEnable = newValue } }
|
|
}
|
|
private let enableSendQueueEnableReceivedInvocationsLock = NSLock()
|
|
private var enableSendQueueEnableUnderlyingReceivedInvocations: [Bool] = []
|
|
open var enableSendQueueEnableReceivedInvocations: [Bool] {
|
|
get { enableSendQueueEnableReceivedInvocationsLock.withLock { enableSendQueueEnableUnderlyingReceivedInvocations } }
|
|
set { enableSendQueueEnableReceivedInvocationsLock.withLock { enableSendQueueEnableUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var enableSendQueueEnableClosure: ((Bool) -> Void)?
|
|
|
|
open override func enableSendQueue(enable: Bool) {
|
|
enableSendQueueEnableCallsCountLock.withLock { enableSendQueueEnableUnderlyingCallsCount += 1 }
|
|
enableSendQueueEnableReceivedEnable = enable
|
|
enableSendQueueEnableReceivedInvocationsLock.withLock { enableSendQueueEnableUnderlyingReceivedInvocations.append(enable) }
|
|
enableSendQueueEnableClosure?(enable)
|
|
}
|
|
|
|
//MARK: - encryptionState
|
|
|
|
private let encryptionStateCallsCountLock = NSLock()
|
|
private var encryptionStateUnderlyingCallsCount = 0
|
|
open var encryptionStateCallsCount: Int {
|
|
get { encryptionStateCallsCountLock.withLock { encryptionStateUnderlyingCallsCount } }
|
|
set { encryptionStateCallsCountLock.withLock { encryptionStateUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var encryptionStateCalled: Bool {
|
|
return encryptionStateCallsCount > 0
|
|
}
|
|
|
|
private let encryptionStateReturnValueLock = NSLock()
|
|
open var encryptionStateUnderlyingReturnValue: EncryptionState!
|
|
open var encryptionStateReturnValue: EncryptionState! {
|
|
get { encryptionStateReturnValueLock.withLock { encryptionStateUnderlyingReturnValue } }
|
|
set { encryptionStateReturnValueLock.withLock { encryptionStateUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var encryptionStateClosure: (() -> EncryptionState)?
|
|
|
|
open override func encryptionState() -> EncryptionState {
|
|
encryptionStateCallsCountLock.withLock { encryptionStateUnderlyingCallsCount += 1 }
|
|
if let encryptionStateClosure = encryptionStateClosure {
|
|
return encryptionStateClosure()
|
|
} else {
|
|
return encryptionStateReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - fetchThreadSubscription
|
|
|
|
open var fetchThreadSubscriptionThreadRootEventIdThrowableError: Error?
|
|
private let fetchThreadSubscriptionThreadRootEventIdCallsCountLock = NSLock()
|
|
private var fetchThreadSubscriptionThreadRootEventIdUnderlyingCallsCount = 0
|
|
open var fetchThreadSubscriptionThreadRootEventIdCallsCount: Int {
|
|
get { fetchThreadSubscriptionThreadRootEventIdCallsCountLock.withLock { fetchThreadSubscriptionThreadRootEventIdUnderlyingCallsCount } }
|
|
set { fetchThreadSubscriptionThreadRootEventIdCallsCountLock.withLock { fetchThreadSubscriptionThreadRootEventIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var fetchThreadSubscriptionThreadRootEventIdCalled: Bool {
|
|
return fetchThreadSubscriptionThreadRootEventIdCallsCount > 0
|
|
}
|
|
private let fetchThreadSubscriptionThreadRootEventIdReceivedThreadRootEventIdLock = NSLock()
|
|
private var fetchThreadSubscriptionThreadRootEventIdUnderlyingReceivedThreadRootEventId: String?
|
|
open var fetchThreadSubscriptionThreadRootEventIdReceivedThreadRootEventId: String? {
|
|
get { fetchThreadSubscriptionThreadRootEventIdReceivedThreadRootEventIdLock.withLock { fetchThreadSubscriptionThreadRootEventIdUnderlyingReceivedThreadRootEventId } }
|
|
set { fetchThreadSubscriptionThreadRootEventIdReceivedThreadRootEventIdLock.withLock { fetchThreadSubscriptionThreadRootEventIdUnderlyingReceivedThreadRootEventId = newValue } }
|
|
}
|
|
private let fetchThreadSubscriptionThreadRootEventIdReceivedInvocationsLock = NSLock()
|
|
private var fetchThreadSubscriptionThreadRootEventIdUnderlyingReceivedInvocations: [String] = []
|
|
open var fetchThreadSubscriptionThreadRootEventIdReceivedInvocations: [String] {
|
|
get { fetchThreadSubscriptionThreadRootEventIdReceivedInvocationsLock.withLock { fetchThreadSubscriptionThreadRootEventIdUnderlyingReceivedInvocations } }
|
|
set { fetchThreadSubscriptionThreadRootEventIdReceivedInvocationsLock.withLock { fetchThreadSubscriptionThreadRootEventIdUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let fetchThreadSubscriptionThreadRootEventIdReturnValueLock = NSLock()
|
|
open var fetchThreadSubscriptionThreadRootEventIdUnderlyingReturnValue: ThreadSubscription?
|
|
open var fetchThreadSubscriptionThreadRootEventIdReturnValue: ThreadSubscription? {
|
|
get { fetchThreadSubscriptionThreadRootEventIdReturnValueLock.withLock { fetchThreadSubscriptionThreadRootEventIdUnderlyingReturnValue } }
|
|
set { fetchThreadSubscriptionThreadRootEventIdReturnValueLock.withLock { fetchThreadSubscriptionThreadRootEventIdUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var fetchThreadSubscriptionThreadRootEventIdClosure: ((String) async throws -> ThreadSubscription?)?
|
|
|
|
open override func fetchThreadSubscription(threadRootEventId: String) async throws -> ThreadSubscription? {
|
|
if let error = fetchThreadSubscriptionThreadRootEventIdThrowableError {
|
|
throw error
|
|
}
|
|
fetchThreadSubscriptionThreadRootEventIdCallsCountLock.withLock { fetchThreadSubscriptionThreadRootEventIdUnderlyingCallsCount += 1 }
|
|
fetchThreadSubscriptionThreadRootEventIdReceivedThreadRootEventId = threadRootEventId
|
|
fetchThreadSubscriptionThreadRootEventIdReceivedInvocationsLock.withLock { fetchThreadSubscriptionThreadRootEventIdUnderlyingReceivedInvocations.append(threadRootEventId) }
|
|
if let fetchThreadSubscriptionThreadRootEventIdClosure = fetchThreadSubscriptionThreadRootEventIdClosure {
|
|
return try await fetchThreadSubscriptionThreadRootEventIdClosure(threadRootEventId)
|
|
} else {
|
|
return fetchThreadSubscriptionThreadRootEventIdReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - forget
|
|
|
|
open var forgetThrowableError: Error?
|
|
private let forgetCallsCountLock = NSLock()
|
|
private var forgetUnderlyingCallsCount = 0
|
|
open var forgetCallsCount: Int {
|
|
get { forgetCallsCountLock.withLock { forgetUnderlyingCallsCount } }
|
|
set { forgetCallsCountLock.withLock { forgetUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var forgetCalled: Bool {
|
|
return forgetCallsCount > 0
|
|
}
|
|
open var forgetClosure: (() async throws -> Void)?
|
|
|
|
open override func forget() async throws {
|
|
if let error = forgetThrowableError {
|
|
throw error
|
|
}
|
|
forgetCallsCountLock.withLock { forgetUnderlyingCallsCount += 1 }
|
|
try await forgetClosure?()
|
|
}
|
|
|
|
//MARK: - getPowerLevels
|
|
|
|
open var getPowerLevelsThrowableError: Error?
|
|
private let getPowerLevelsCallsCountLock = NSLock()
|
|
private var getPowerLevelsUnderlyingCallsCount = 0
|
|
open var getPowerLevelsCallsCount: Int {
|
|
get { getPowerLevelsCallsCountLock.withLock { getPowerLevelsUnderlyingCallsCount } }
|
|
set { getPowerLevelsCallsCountLock.withLock { getPowerLevelsUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var getPowerLevelsCalled: Bool {
|
|
return getPowerLevelsCallsCount > 0
|
|
}
|
|
|
|
private let getPowerLevelsReturnValueLock = NSLock()
|
|
open var getPowerLevelsUnderlyingReturnValue: RoomPowerLevels!
|
|
open var getPowerLevelsReturnValue: RoomPowerLevels! {
|
|
get { getPowerLevelsReturnValueLock.withLock { getPowerLevelsUnderlyingReturnValue } }
|
|
set { getPowerLevelsReturnValueLock.withLock { getPowerLevelsUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var getPowerLevelsClosure: (() async throws -> RoomPowerLevels)?
|
|
|
|
open override func getPowerLevels() async throws -> RoomPowerLevels {
|
|
if let error = getPowerLevelsThrowableError {
|
|
throw error
|
|
}
|
|
getPowerLevelsCallsCountLock.withLock { getPowerLevelsUnderlyingCallsCount += 1 }
|
|
if let getPowerLevelsClosure = getPowerLevelsClosure {
|
|
return try await getPowerLevelsClosure()
|
|
} else {
|
|
return getPowerLevelsReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - getRoomVisibility
|
|
|
|
open var getRoomVisibilityThrowableError: Error?
|
|
private let getRoomVisibilityCallsCountLock = NSLock()
|
|
private var getRoomVisibilityUnderlyingCallsCount = 0
|
|
open var getRoomVisibilityCallsCount: Int {
|
|
get { getRoomVisibilityCallsCountLock.withLock { getRoomVisibilityUnderlyingCallsCount } }
|
|
set { getRoomVisibilityCallsCountLock.withLock { getRoomVisibilityUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var getRoomVisibilityCalled: Bool {
|
|
return getRoomVisibilityCallsCount > 0
|
|
}
|
|
|
|
private let getRoomVisibilityReturnValueLock = NSLock()
|
|
open var getRoomVisibilityUnderlyingReturnValue: RoomVisibility!
|
|
open var getRoomVisibilityReturnValue: RoomVisibility! {
|
|
get { getRoomVisibilityReturnValueLock.withLock { getRoomVisibilityUnderlyingReturnValue } }
|
|
set { getRoomVisibilityReturnValueLock.withLock { getRoomVisibilityUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var getRoomVisibilityClosure: (() async throws -> RoomVisibility)?
|
|
|
|
open override func getRoomVisibility() async throws -> RoomVisibility {
|
|
if let error = getRoomVisibilityThrowableError {
|
|
throw error
|
|
}
|
|
getRoomVisibilityCallsCountLock.withLock { getRoomVisibilityUnderlyingCallsCount += 1 }
|
|
if let getRoomVisibilityClosure = getRoomVisibilityClosure {
|
|
return try await getRoomVisibilityClosure()
|
|
} else {
|
|
return getRoomVisibilityReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - hasActiveRoomCall
|
|
|
|
private let hasActiveRoomCallCallsCountLock = NSLock()
|
|
private var hasActiveRoomCallUnderlyingCallsCount = 0
|
|
open var hasActiveRoomCallCallsCount: Int {
|
|
get { hasActiveRoomCallCallsCountLock.withLock { hasActiveRoomCallUnderlyingCallsCount } }
|
|
set { hasActiveRoomCallCallsCountLock.withLock { hasActiveRoomCallUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var hasActiveRoomCallCalled: Bool {
|
|
return hasActiveRoomCallCallsCount > 0
|
|
}
|
|
|
|
private let hasActiveRoomCallReturnValueLock = NSLock()
|
|
open var hasActiveRoomCallUnderlyingReturnValue: Bool!
|
|
open var hasActiveRoomCallReturnValue: Bool! {
|
|
get { hasActiveRoomCallReturnValueLock.withLock { hasActiveRoomCallUnderlyingReturnValue } }
|
|
set { hasActiveRoomCallReturnValueLock.withLock { hasActiveRoomCallUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var hasActiveRoomCallClosure: (() -> Bool)?
|
|
|
|
open override func hasActiveRoomCall() -> Bool {
|
|
hasActiveRoomCallCallsCountLock.withLock { hasActiveRoomCallUnderlyingCallsCount += 1 }
|
|
if let hasActiveRoomCallClosure = hasActiveRoomCallClosure {
|
|
return hasActiveRoomCallClosure()
|
|
} else {
|
|
return hasActiveRoomCallReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - heroes
|
|
|
|
private let heroesCallsCountLock = NSLock()
|
|
private var heroesUnderlyingCallsCount = 0
|
|
open var heroesCallsCount: Int {
|
|
get { heroesCallsCountLock.withLock { heroesUnderlyingCallsCount } }
|
|
set { heroesCallsCountLock.withLock { heroesUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var heroesCalled: Bool {
|
|
return heroesCallsCount > 0
|
|
}
|
|
|
|
private let heroesReturnValueLock = NSLock()
|
|
open var heroesUnderlyingReturnValue: [RoomHero]!
|
|
open var heroesReturnValue: [RoomHero]! {
|
|
get { heroesReturnValueLock.withLock { heroesUnderlyingReturnValue } }
|
|
set { heroesReturnValueLock.withLock { heroesUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var heroesClosure: (() -> [RoomHero])?
|
|
|
|
open override func heroes() -> [RoomHero] {
|
|
heroesCallsCountLock.withLock { heroesUnderlyingCallsCount += 1 }
|
|
if let heroesClosure = heroesClosure {
|
|
return heroesClosure()
|
|
} else {
|
|
return heroesReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - id
|
|
|
|
private let idCallsCountLock = NSLock()
|
|
private var idUnderlyingCallsCount = 0
|
|
open var idCallsCount: Int {
|
|
get { idCallsCountLock.withLock { idUnderlyingCallsCount } }
|
|
set { idCallsCountLock.withLock { idUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var idCalled: Bool {
|
|
return idCallsCount > 0
|
|
}
|
|
|
|
private let idReturnValueLock = NSLock()
|
|
open var idUnderlyingReturnValue: String!
|
|
open var idReturnValue: String! {
|
|
get { idReturnValueLock.withLock { idUnderlyingReturnValue } }
|
|
set { idReturnValueLock.withLock { idUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var idClosure: (() -> String)?
|
|
|
|
open override func id() -> String {
|
|
idCallsCountLock.withLock { idUnderlyingCallsCount += 1 }
|
|
if let idClosure = idClosure {
|
|
return idClosure()
|
|
} else {
|
|
return idReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - ignoreDeviceTrustAndResend
|
|
|
|
open var ignoreDeviceTrustAndResendDevicesSendHandleThrowableError: Error?
|
|
private let ignoreDeviceTrustAndResendDevicesSendHandleCallsCountLock = NSLock()
|
|
private var ignoreDeviceTrustAndResendDevicesSendHandleUnderlyingCallsCount = 0
|
|
open var ignoreDeviceTrustAndResendDevicesSendHandleCallsCount: Int {
|
|
get { ignoreDeviceTrustAndResendDevicesSendHandleCallsCountLock.withLock { ignoreDeviceTrustAndResendDevicesSendHandleUnderlyingCallsCount } }
|
|
set { ignoreDeviceTrustAndResendDevicesSendHandleCallsCountLock.withLock { ignoreDeviceTrustAndResendDevicesSendHandleUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var ignoreDeviceTrustAndResendDevicesSendHandleCalled: Bool {
|
|
return ignoreDeviceTrustAndResendDevicesSendHandleCallsCount > 0
|
|
}
|
|
private let ignoreDeviceTrustAndResendDevicesSendHandleReceivedArgumentsLock = NSLock()
|
|
private var ignoreDeviceTrustAndResendDevicesSendHandleUnderlyingReceivedArguments: (devices: [String: [String]], sendHandle: SendHandle)?
|
|
open var ignoreDeviceTrustAndResendDevicesSendHandleReceivedArguments: (devices: [String: [String]], sendHandle: SendHandle)? {
|
|
get { ignoreDeviceTrustAndResendDevicesSendHandleReceivedArgumentsLock.withLock { ignoreDeviceTrustAndResendDevicesSendHandleUnderlyingReceivedArguments } }
|
|
set { ignoreDeviceTrustAndResendDevicesSendHandleReceivedArgumentsLock.withLock { ignoreDeviceTrustAndResendDevicesSendHandleUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let ignoreDeviceTrustAndResendDevicesSendHandleReceivedInvocationsLock = NSLock()
|
|
private var ignoreDeviceTrustAndResendDevicesSendHandleUnderlyingReceivedInvocations: [(devices: [String: [String]], sendHandle: SendHandle)] = []
|
|
open var ignoreDeviceTrustAndResendDevicesSendHandleReceivedInvocations: [(devices: [String: [String]], sendHandle: SendHandle)] {
|
|
get { ignoreDeviceTrustAndResendDevicesSendHandleReceivedInvocationsLock.withLock { ignoreDeviceTrustAndResendDevicesSendHandleUnderlyingReceivedInvocations } }
|
|
set { ignoreDeviceTrustAndResendDevicesSendHandleReceivedInvocationsLock.withLock { ignoreDeviceTrustAndResendDevicesSendHandleUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var ignoreDeviceTrustAndResendDevicesSendHandleClosure: (([String: [String]], SendHandle) async throws -> Void)?
|
|
|
|
open override func ignoreDeviceTrustAndResend(devices: [String: [String]], sendHandle: SendHandle) async throws {
|
|
if let error = ignoreDeviceTrustAndResendDevicesSendHandleThrowableError {
|
|
throw error
|
|
}
|
|
ignoreDeviceTrustAndResendDevicesSendHandleCallsCountLock.withLock { ignoreDeviceTrustAndResendDevicesSendHandleUnderlyingCallsCount += 1 }
|
|
ignoreDeviceTrustAndResendDevicesSendHandleReceivedArguments = (devices: devices, sendHandle: sendHandle)
|
|
ignoreDeviceTrustAndResendDevicesSendHandleReceivedInvocationsLock.withLock { ignoreDeviceTrustAndResendDevicesSendHandleUnderlyingReceivedInvocations.append((devices: devices, sendHandle: sendHandle)) }
|
|
try await ignoreDeviceTrustAndResendDevicesSendHandleClosure?(devices, sendHandle)
|
|
}
|
|
|
|
//MARK: - ignoreUser
|
|
|
|
open var ignoreUserUserIdThrowableError: Error?
|
|
private let ignoreUserUserIdCallsCountLock = NSLock()
|
|
private var ignoreUserUserIdUnderlyingCallsCount = 0
|
|
open var ignoreUserUserIdCallsCount: Int {
|
|
get { ignoreUserUserIdCallsCountLock.withLock { ignoreUserUserIdUnderlyingCallsCount } }
|
|
set { ignoreUserUserIdCallsCountLock.withLock { ignoreUserUserIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var ignoreUserUserIdCalled: Bool {
|
|
return ignoreUserUserIdCallsCount > 0
|
|
}
|
|
private let ignoreUserUserIdReceivedUserIdLock = NSLock()
|
|
private var ignoreUserUserIdUnderlyingReceivedUserId: String?
|
|
open var ignoreUserUserIdReceivedUserId: String? {
|
|
get { ignoreUserUserIdReceivedUserIdLock.withLock { ignoreUserUserIdUnderlyingReceivedUserId } }
|
|
set { ignoreUserUserIdReceivedUserIdLock.withLock { ignoreUserUserIdUnderlyingReceivedUserId = newValue } }
|
|
}
|
|
private let ignoreUserUserIdReceivedInvocationsLock = NSLock()
|
|
private var ignoreUserUserIdUnderlyingReceivedInvocations: [String] = []
|
|
open var ignoreUserUserIdReceivedInvocations: [String] {
|
|
get { ignoreUserUserIdReceivedInvocationsLock.withLock { ignoreUserUserIdUnderlyingReceivedInvocations } }
|
|
set { ignoreUserUserIdReceivedInvocationsLock.withLock { ignoreUserUserIdUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var ignoreUserUserIdClosure: ((String) async throws -> Void)?
|
|
|
|
open override func ignoreUser(userId: String) async throws {
|
|
if let error = ignoreUserUserIdThrowableError {
|
|
throw error
|
|
}
|
|
ignoreUserUserIdCallsCountLock.withLock { ignoreUserUserIdUnderlyingCallsCount += 1 }
|
|
ignoreUserUserIdReceivedUserId = userId
|
|
ignoreUserUserIdReceivedInvocationsLock.withLock { ignoreUserUserIdUnderlyingReceivedInvocations.append(userId) }
|
|
try await ignoreUserUserIdClosure?(userId)
|
|
}
|
|
|
|
//MARK: - inviteUserById
|
|
|
|
open var inviteUserByIdUserIdThrowableError: Error?
|
|
private let inviteUserByIdUserIdCallsCountLock = NSLock()
|
|
private var inviteUserByIdUserIdUnderlyingCallsCount = 0
|
|
open var inviteUserByIdUserIdCallsCount: Int {
|
|
get { inviteUserByIdUserIdCallsCountLock.withLock { inviteUserByIdUserIdUnderlyingCallsCount } }
|
|
set { inviteUserByIdUserIdCallsCountLock.withLock { inviteUserByIdUserIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var inviteUserByIdUserIdCalled: Bool {
|
|
return inviteUserByIdUserIdCallsCount > 0
|
|
}
|
|
private let inviteUserByIdUserIdReceivedUserIdLock = NSLock()
|
|
private var inviteUserByIdUserIdUnderlyingReceivedUserId: String?
|
|
open var inviteUserByIdUserIdReceivedUserId: String? {
|
|
get { inviteUserByIdUserIdReceivedUserIdLock.withLock { inviteUserByIdUserIdUnderlyingReceivedUserId } }
|
|
set { inviteUserByIdUserIdReceivedUserIdLock.withLock { inviteUserByIdUserIdUnderlyingReceivedUserId = newValue } }
|
|
}
|
|
private let inviteUserByIdUserIdReceivedInvocationsLock = NSLock()
|
|
private var inviteUserByIdUserIdUnderlyingReceivedInvocations: [String] = []
|
|
open var inviteUserByIdUserIdReceivedInvocations: [String] {
|
|
get { inviteUserByIdUserIdReceivedInvocationsLock.withLock { inviteUserByIdUserIdUnderlyingReceivedInvocations } }
|
|
set { inviteUserByIdUserIdReceivedInvocationsLock.withLock { inviteUserByIdUserIdUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var inviteUserByIdUserIdClosure: ((String) async throws -> Void)?
|
|
|
|
open override func inviteUserById(userId: String) async throws {
|
|
if let error = inviteUserByIdUserIdThrowableError {
|
|
throw error
|
|
}
|
|
inviteUserByIdUserIdCallsCountLock.withLock { inviteUserByIdUserIdUnderlyingCallsCount += 1 }
|
|
inviteUserByIdUserIdReceivedUserId = userId
|
|
inviteUserByIdUserIdReceivedInvocationsLock.withLock { inviteUserByIdUserIdUnderlyingReceivedInvocations.append(userId) }
|
|
try await inviteUserByIdUserIdClosure?(userId)
|
|
}
|
|
|
|
//MARK: - invitedMembersCount
|
|
|
|
private let invitedMembersCountCallsCountLock = NSLock()
|
|
private var invitedMembersCountUnderlyingCallsCount = 0
|
|
open var invitedMembersCountCallsCount: Int {
|
|
get { invitedMembersCountCallsCountLock.withLock { invitedMembersCountUnderlyingCallsCount } }
|
|
set { invitedMembersCountCallsCountLock.withLock { invitedMembersCountUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var invitedMembersCountCalled: Bool {
|
|
return invitedMembersCountCallsCount > 0
|
|
}
|
|
|
|
private let invitedMembersCountReturnValueLock = NSLock()
|
|
open var invitedMembersCountUnderlyingReturnValue: UInt64!
|
|
open var invitedMembersCountReturnValue: UInt64! {
|
|
get { invitedMembersCountReturnValueLock.withLock { invitedMembersCountUnderlyingReturnValue } }
|
|
set { invitedMembersCountReturnValueLock.withLock { invitedMembersCountUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var invitedMembersCountClosure: (() -> UInt64)?
|
|
|
|
open override func invitedMembersCount() -> UInt64 {
|
|
invitedMembersCountCallsCountLock.withLock { invitedMembersCountUnderlyingCallsCount += 1 }
|
|
if let invitedMembersCountClosure = invitedMembersCountClosure {
|
|
return invitedMembersCountClosure()
|
|
} else {
|
|
return invitedMembersCountReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - inviter
|
|
|
|
open var inviterThrowableError: Error?
|
|
private let inviterCallsCountLock = NSLock()
|
|
private var inviterUnderlyingCallsCount = 0
|
|
open var inviterCallsCount: Int {
|
|
get { inviterCallsCountLock.withLock { inviterUnderlyingCallsCount } }
|
|
set { inviterCallsCountLock.withLock { inviterUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var inviterCalled: Bool {
|
|
return inviterCallsCount > 0
|
|
}
|
|
|
|
private let inviterReturnValueLock = NSLock()
|
|
open var inviterUnderlyingReturnValue: RoomMember?
|
|
open var inviterReturnValue: RoomMember? {
|
|
get { inviterReturnValueLock.withLock { inviterUnderlyingReturnValue } }
|
|
set { inviterReturnValueLock.withLock { inviterUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var inviterClosure: (() async throws -> RoomMember?)?
|
|
|
|
open override func inviter() async throws -> RoomMember? {
|
|
if let error = inviterThrowableError {
|
|
throw error
|
|
}
|
|
inviterCallsCountLock.withLock { inviterUnderlyingCallsCount += 1 }
|
|
if let inviterClosure = inviterClosure {
|
|
return try await inviterClosure()
|
|
} else {
|
|
return inviterReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - isDirect
|
|
|
|
private let isDirectCallsCountLock = NSLock()
|
|
private var isDirectUnderlyingCallsCount = 0
|
|
open var isDirectCallsCount: Int {
|
|
get { isDirectCallsCountLock.withLock { isDirectUnderlyingCallsCount } }
|
|
set { isDirectCallsCountLock.withLock { isDirectUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var isDirectCalled: Bool {
|
|
return isDirectCallsCount > 0
|
|
}
|
|
|
|
private let isDirectReturnValueLock = NSLock()
|
|
open var isDirectUnderlyingReturnValue: Bool!
|
|
open var isDirectReturnValue: Bool! {
|
|
get { isDirectReturnValueLock.withLock { isDirectUnderlyingReturnValue } }
|
|
set { isDirectReturnValueLock.withLock { isDirectUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var isDirectClosure: (() async -> Bool)?
|
|
|
|
open override func isDirect() async -> Bool {
|
|
isDirectCallsCountLock.withLock { isDirectUnderlyingCallsCount += 1 }
|
|
if let isDirectClosure = isDirectClosure {
|
|
return await isDirectClosure()
|
|
} else {
|
|
return isDirectReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - isEncrypted
|
|
|
|
private let isEncryptedCallsCountLock = NSLock()
|
|
private var isEncryptedUnderlyingCallsCount = 0
|
|
open var isEncryptedCallsCount: Int {
|
|
get { isEncryptedCallsCountLock.withLock { isEncryptedUnderlyingCallsCount } }
|
|
set { isEncryptedCallsCountLock.withLock { isEncryptedUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var isEncryptedCalled: Bool {
|
|
return isEncryptedCallsCount > 0
|
|
}
|
|
|
|
private let isEncryptedReturnValueLock = NSLock()
|
|
open var isEncryptedUnderlyingReturnValue: Bool!
|
|
open var isEncryptedReturnValue: Bool! {
|
|
get { isEncryptedReturnValueLock.withLock { isEncryptedUnderlyingReturnValue } }
|
|
set { isEncryptedReturnValueLock.withLock { isEncryptedUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var isEncryptedClosure: (() async -> Bool)?
|
|
|
|
open override func isEncrypted() async -> Bool {
|
|
isEncryptedCallsCountLock.withLock { isEncryptedUnderlyingCallsCount += 1 }
|
|
if let isEncryptedClosure = isEncryptedClosure {
|
|
return await isEncryptedClosure()
|
|
} else {
|
|
return isEncryptedReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - isPublic
|
|
|
|
private let isPublicCallsCountLock = NSLock()
|
|
private var isPublicUnderlyingCallsCount = 0
|
|
open var isPublicCallsCount: Int {
|
|
get { isPublicCallsCountLock.withLock { isPublicUnderlyingCallsCount } }
|
|
set { isPublicCallsCountLock.withLock { isPublicUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var isPublicCalled: Bool {
|
|
return isPublicCallsCount > 0
|
|
}
|
|
|
|
private let isPublicReturnValueLock = NSLock()
|
|
open var isPublicUnderlyingReturnValue: Bool?
|
|
open var isPublicReturnValue: Bool? {
|
|
get { isPublicReturnValueLock.withLock { isPublicUnderlyingReturnValue } }
|
|
set { isPublicReturnValueLock.withLock { isPublicUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var isPublicClosure: (() -> Bool?)?
|
|
|
|
open override func isPublic() -> Bool? {
|
|
isPublicCallsCountLock.withLock { isPublicUnderlyingCallsCount += 1 }
|
|
if let isPublicClosure = isPublicClosure {
|
|
return isPublicClosure()
|
|
} else {
|
|
return isPublicReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - isSendQueueEnabled
|
|
|
|
private let isSendQueueEnabledCallsCountLock = NSLock()
|
|
private var isSendQueueEnabledUnderlyingCallsCount = 0
|
|
open var isSendQueueEnabledCallsCount: Int {
|
|
get { isSendQueueEnabledCallsCountLock.withLock { isSendQueueEnabledUnderlyingCallsCount } }
|
|
set { isSendQueueEnabledCallsCountLock.withLock { isSendQueueEnabledUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var isSendQueueEnabledCalled: Bool {
|
|
return isSendQueueEnabledCallsCount > 0
|
|
}
|
|
|
|
private let isSendQueueEnabledReturnValueLock = NSLock()
|
|
open var isSendQueueEnabledUnderlyingReturnValue: Bool!
|
|
open var isSendQueueEnabledReturnValue: Bool! {
|
|
get { isSendQueueEnabledReturnValueLock.withLock { isSendQueueEnabledUnderlyingReturnValue } }
|
|
set { isSendQueueEnabledReturnValueLock.withLock { isSendQueueEnabledUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var isSendQueueEnabledClosure: (() -> Bool)?
|
|
|
|
open override func isSendQueueEnabled() -> Bool {
|
|
isSendQueueEnabledCallsCountLock.withLock { isSendQueueEnabledUnderlyingCallsCount += 1 }
|
|
if let isSendQueueEnabledClosure = isSendQueueEnabledClosure {
|
|
return isSendQueueEnabledClosure()
|
|
} else {
|
|
return isSendQueueEnabledReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - isSpace
|
|
|
|
private let isSpaceCallsCountLock = NSLock()
|
|
private var isSpaceUnderlyingCallsCount = 0
|
|
open var isSpaceCallsCount: Int {
|
|
get { isSpaceCallsCountLock.withLock { isSpaceUnderlyingCallsCount } }
|
|
set { isSpaceCallsCountLock.withLock { isSpaceUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var isSpaceCalled: Bool {
|
|
return isSpaceCallsCount > 0
|
|
}
|
|
|
|
private let isSpaceReturnValueLock = NSLock()
|
|
open var isSpaceUnderlyingReturnValue: Bool!
|
|
open var isSpaceReturnValue: Bool! {
|
|
get { isSpaceReturnValueLock.withLock { isSpaceUnderlyingReturnValue } }
|
|
set { isSpaceReturnValueLock.withLock { isSpaceUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var isSpaceClosure: (() -> Bool)?
|
|
|
|
open override func isSpace() -> Bool {
|
|
isSpaceCallsCountLock.withLock { isSpaceUnderlyingCallsCount += 1 }
|
|
if let isSpaceClosure = isSpaceClosure {
|
|
return isSpaceClosure()
|
|
} else {
|
|
return isSpaceReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - join
|
|
|
|
open var joinThrowableError: Error?
|
|
private let joinCallsCountLock = NSLock()
|
|
private var joinUnderlyingCallsCount = 0
|
|
open var joinCallsCount: Int {
|
|
get { joinCallsCountLock.withLock { joinUnderlyingCallsCount } }
|
|
set { joinCallsCountLock.withLock { joinUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var joinCalled: Bool {
|
|
return joinCallsCount > 0
|
|
}
|
|
open var joinClosure: (() async throws -> Void)?
|
|
|
|
open override func join() async throws {
|
|
if let error = joinThrowableError {
|
|
throw error
|
|
}
|
|
joinCallsCountLock.withLock { joinUnderlyingCallsCount += 1 }
|
|
try await joinClosure?()
|
|
}
|
|
|
|
//MARK: - joinedMembersCount
|
|
|
|
private let joinedMembersCountCallsCountLock = NSLock()
|
|
private var joinedMembersCountUnderlyingCallsCount = 0
|
|
open var joinedMembersCountCallsCount: Int {
|
|
get { joinedMembersCountCallsCountLock.withLock { joinedMembersCountUnderlyingCallsCount } }
|
|
set { joinedMembersCountCallsCountLock.withLock { joinedMembersCountUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var joinedMembersCountCalled: Bool {
|
|
return joinedMembersCountCallsCount > 0
|
|
}
|
|
|
|
private let joinedMembersCountReturnValueLock = NSLock()
|
|
open var joinedMembersCountUnderlyingReturnValue: UInt64!
|
|
open var joinedMembersCountReturnValue: UInt64! {
|
|
get { joinedMembersCountReturnValueLock.withLock { joinedMembersCountUnderlyingReturnValue } }
|
|
set { joinedMembersCountReturnValueLock.withLock { joinedMembersCountUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var joinedMembersCountClosure: (() -> UInt64)?
|
|
|
|
open override func joinedMembersCount() -> UInt64 {
|
|
joinedMembersCountCallsCountLock.withLock { joinedMembersCountUnderlyingCallsCount += 1 }
|
|
if let joinedMembersCountClosure = joinedMembersCountClosure {
|
|
return joinedMembersCountClosure()
|
|
} else {
|
|
return joinedMembersCountReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - kickUser
|
|
|
|
open var kickUserUserIdReasonThrowableError: Error?
|
|
private let kickUserUserIdReasonCallsCountLock = NSLock()
|
|
private var kickUserUserIdReasonUnderlyingCallsCount = 0
|
|
open var kickUserUserIdReasonCallsCount: Int {
|
|
get { kickUserUserIdReasonCallsCountLock.withLock { kickUserUserIdReasonUnderlyingCallsCount } }
|
|
set { kickUserUserIdReasonCallsCountLock.withLock { kickUserUserIdReasonUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var kickUserUserIdReasonCalled: Bool {
|
|
return kickUserUserIdReasonCallsCount > 0
|
|
}
|
|
private let kickUserUserIdReasonReceivedArgumentsLock = NSLock()
|
|
private var kickUserUserIdReasonUnderlyingReceivedArguments: (userId: String, reason: String?)?
|
|
open var kickUserUserIdReasonReceivedArguments: (userId: String, reason: String?)? {
|
|
get { kickUserUserIdReasonReceivedArgumentsLock.withLock { kickUserUserIdReasonUnderlyingReceivedArguments } }
|
|
set { kickUserUserIdReasonReceivedArgumentsLock.withLock { kickUserUserIdReasonUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let kickUserUserIdReasonReceivedInvocationsLock = NSLock()
|
|
private var kickUserUserIdReasonUnderlyingReceivedInvocations: [(userId: String, reason: String?)] = []
|
|
open var kickUserUserIdReasonReceivedInvocations: [(userId: String, reason: String?)] {
|
|
get { kickUserUserIdReasonReceivedInvocationsLock.withLock { kickUserUserIdReasonUnderlyingReceivedInvocations } }
|
|
set { kickUserUserIdReasonReceivedInvocationsLock.withLock { kickUserUserIdReasonUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var kickUserUserIdReasonClosure: ((String, String?) async throws -> Void)?
|
|
|
|
open override func kickUser(userId: String, reason: String?) async throws {
|
|
if let error = kickUserUserIdReasonThrowableError {
|
|
throw error
|
|
}
|
|
kickUserUserIdReasonCallsCountLock.withLock { kickUserUserIdReasonUnderlyingCallsCount += 1 }
|
|
kickUserUserIdReasonReceivedArguments = (userId: userId, reason: reason)
|
|
kickUserUserIdReasonReceivedInvocationsLock.withLock { kickUserUserIdReasonUnderlyingReceivedInvocations.append((userId: userId, reason: reason)) }
|
|
try await kickUserUserIdReasonClosure?(userId, reason)
|
|
}
|
|
|
|
//MARK: - latestEncryptionState
|
|
|
|
open var latestEncryptionStateThrowableError: Error?
|
|
private let latestEncryptionStateCallsCountLock = NSLock()
|
|
private var latestEncryptionStateUnderlyingCallsCount = 0
|
|
open var latestEncryptionStateCallsCount: Int {
|
|
get { latestEncryptionStateCallsCountLock.withLock { latestEncryptionStateUnderlyingCallsCount } }
|
|
set { latestEncryptionStateCallsCountLock.withLock { latestEncryptionStateUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var latestEncryptionStateCalled: Bool {
|
|
return latestEncryptionStateCallsCount > 0
|
|
}
|
|
|
|
private let latestEncryptionStateReturnValueLock = NSLock()
|
|
open var latestEncryptionStateUnderlyingReturnValue: EncryptionState!
|
|
open var latestEncryptionStateReturnValue: EncryptionState! {
|
|
get { latestEncryptionStateReturnValueLock.withLock { latestEncryptionStateUnderlyingReturnValue } }
|
|
set { latestEncryptionStateReturnValueLock.withLock { latestEncryptionStateUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var latestEncryptionStateClosure: (() async throws -> EncryptionState)?
|
|
|
|
open override func latestEncryptionState() async throws -> EncryptionState {
|
|
if let error = latestEncryptionStateThrowableError {
|
|
throw error
|
|
}
|
|
latestEncryptionStateCallsCountLock.withLock { latestEncryptionStateUnderlyingCallsCount += 1 }
|
|
if let latestEncryptionStateClosure = latestEncryptionStateClosure {
|
|
return try await latestEncryptionStateClosure()
|
|
} else {
|
|
return latestEncryptionStateReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - latestEvent
|
|
|
|
private let latestEventCallsCountLock = NSLock()
|
|
private var latestEventUnderlyingCallsCount = 0
|
|
open var latestEventCallsCount: Int {
|
|
get { latestEventCallsCountLock.withLock { latestEventUnderlyingCallsCount } }
|
|
set { latestEventCallsCountLock.withLock { latestEventUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var latestEventCalled: Bool {
|
|
return latestEventCallsCount > 0
|
|
}
|
|
|
|
private let latestEventReturnValueLock = NSLock()
|
|
open var latestEventUnderlyingReturnValue: LatestEventValue!
|
|
open var latestEventReturnValue: LatestEventValue! {
|
|
get { latestEventReturnValueLock.withLock { latestEventUnderlyingReturnValue } }
|
|
set { latestEventReturnValueLock.withLock { latestEventUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var latestEventClosure: (() async -> LatestEventValue)?
|
|
|
|
open override func latestEvent() async -> LatestEventValue {
|
|
latestEventCallsCountLock.withLock { latestEventUnderlyingCallsCount += 1 }
|
|
if let latestEventClosure = latestEventClosure {
|
|
return await latestEventClosure()
|
|
} else {
|
|
return latestEventReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - leave
|
|
|
|
open var leaveThrowableError: Error?
|
|
private let leaveCallsCountLock = NSLock()
|
|
private var leaveUnderlyingCallsCount = 0
|
|
open var leaveCallsCount: Int {
|
|
get { leaveCallsCountLock.withLock { leaveUnderlyingCallsCount } }
|
|
set { leaveCallsCountLock.withLock { leaveUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var leaveCalled: Bool {
|
|
return leaveCallsCount > 0
|
|
}
|
|
open var leaveClosure: (() async throws -> Void)?
|
|
|
|
open override func leave() async throws {
|
|
if let error = leaveThrowableError {
|
|
throw error
|
|
}
|
|
leaveCallsCountLock.withLock { leaveUnderlyingCallsCount += 1 }
|
|
try await leaveClosure?()
|
|
}
|
|
|
|
//MARK: - liveLocationsObserver
|
|
|
|
private let liveLocationsObserverCallsCountLock = NSLock()
|
|
private var liveLocationsObserverUnderlyingCallsCount = 0
|
|
open var liveLocationsObserverCallsCount: Int {
|
|
get { liveLocationsObserverCallsCountLock.withLock { liveLocationsObserverUnderlyingCallsCount } }
|
|
set { liveLocationsObserverCallsCountLock.withLock { liveLocationsObserverUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var liveLocationsObserverCalled: Bool {
|
|
return liveLocationsObserverCallsCount > 0
|
|
}
|
|
|
|
private let liveLocationsObserverReturnValueLock = NSLock()
|
|
open var liveLocationsObserverUnderlyingReturnValue: LiveLocationsObserver!
|
|
open var liveLocationsObserverReturnValue: LiveLocationsObserver! {
|
|
get { liveLocationsObserverReturnValueLock.withLock { liveLocationsObserverUnderlyingReturnValue } }
|
|
set { liveLocationsObserverReturnValueLock.withLock { liveLocationsObserverUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var liveLocationsObserverClosure: (() async -> LiveLocationsObserver)?
|
|
|
|
open override func liveLocationsObserver() async -> LiveLocationsObserver {
|
|
liveLocationsObserverCallsCountLock.withLock { liveLocationsObserverUnderlyingCallsCount += 1 }
|
|
if let liveLocationsObserverClosure = liveLocationsObserverClosure {
|
|
return await liveLocationsObserverClosure()
|
|
} else {
|
|
return liveLocationsObserverReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - loadComposerDraft
|
|
|
|
open var loadComposerDraftThreadRootThrowableError: Error?
|
|
private let loadComposerDraftThreadRootCallsCountLock = NSLock()
|
|
private var loadComposerDraftThreadRootUnderlyingCallsCount = 0
|
|
open var loadComposerDraftThreadRootCallsCount: Int {
|
|
get { loadComposerDraftThreadRootCallsCountLock.withLock { loadComposerDraftThreadRootUnderlyingCallsCount } }
|
|
set { loadComposerDraftThreadRootCallsCountLock.withLock { loadComposerDraftThreadRootUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var loadComposerDraftThreadRootCalled: Bool {
|
|
return loadComposerDraftThreadRootCallsCount > 0
|
|
}
|
|
private let loadComposerDraftThreadRootReceivedThreadRootLock = NSLock()
|
|
private var loadComposerDraftThreadRootUnderlyingReceivedThreadRoot: String?
|
|
open var loadComposerDraftThreadRootReceivedThreadRoot: String? {
|
|
get { loadComposerDraftThreadRootReceivedThreadRootLock.withLock { loadComposerDraftThreadRootUnderlyingReceivedThreadRoot } }
|
|
set { loadComposerDraftThreadRootReceivedThreadRootLock.withLock { loadComposerDraftThreadRootUnderlyingReceivedThreadRoot = newValue } }
|
|
}
|
|
private let loadComposerDraftThreadRootReceivedInvocationsLock = NSLock()
|
|
private var loadComposerDraftThreadRootUnderlyingReceivedInvocations: [String?] = []
|
|
open var loadComposerDraftThreadRootReceivedInvocations: [String?] {
|
|
get { loadComposerDraftThreadRootReceivedInvocationsLock.withLock { loadComposerDraftThreadRootUnderlyingReceivedInvocations } }
|
|
set { loadComposerDraftThreadRootReceivedInvocationsLock.withLock { loadComposerDraftThreadRootUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let loadComposerDraftThreadRootReturnValueLock = NSLock()
|
|
open var loadComposerDraftThreadRootUnderlyingReturnValue: ComposerDraft?
|
|
open var loadComposerDraftThreadRootReturnValue: ComposerDraft? {
|
|
get { loadComposerDraftThreadRootReturnValueLock.withLock { loadComposerDraftThreadRootUnderlyingReturnValue } }
|
|
set { loadComposerDraftThreadRootReturnValueLock.withLock { loadComposerDraftThreadRootUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var loadComposerDraftThreadRootClosure: ((String?) async throws -> ComposerDraft?)?
|
|
|
|
open override func loadComposerDraft(threadRoot: String?) async throws -> ComposerDraft? {
|
|
if let error = loadComposerDraftThreadRootThrowableError {
|
|
throw error
|
|
}
|
|
loadComposerDraftThreadRootCallsCountLock.withLock { loadComposerDraftThreadRootUnderlyingCallsCount += 1 }
|
|
loadComposerDraftThreadRootReceivedThreadRoot = threadRoot
|
|
loadComposerDraftThreadRootReceivedInvocationsLock.withLock { loadComposerDraftThreadRootUnderlyingReceivedInvocations.append(threadRoot) }
|
|
if let loadComposerDraftThreadRootClosure = loadComposerDraftThreadRootClosure {
|
|
return try await loadComposerDraftThreadRootClosure(threadRoot)
|
|
} else {
|
|
return loadComposerDraftThreadRootReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - loadOrFetchEvent
|
|
|
|
open var loadOrFetchEventEventIdThrowableError: Error?
|
|
private let loadOrFetchEventEventIdCallsCountLock = NSLock()
|
|
private var loadOrFetchEventEventIdUnderlyingCallsCount = 0
|
|
open var loadOrFetchEventEventIdCallsCount: Int {
|
|
get { loadOrFetchEventEventIdCallsCountLock.withLock { loadOrFetchEventEventIdUnderlyingCallsCount } }
|
|
set { loadOrFetchEventEventIdCallsCountLock.withLock { loadOrFetchEventEventIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var loadOrFetchEventEventIdCalled: Bool {
|
|
return loadOrFetchEventEventIdCallsCount > 0
|
|
}
|
|
private let loadOrFetchEventEventIdReceivedEventIdLock = NSLock()
|
|
private var loadOrFetchEventEventIdUnderlyingReceivedEventId: String?
|
|
open var loadOrFetchEventEventIdReceivedEventId: String? {
|
|
get { loadOrFetchEventEventIdReceivedEventIdLock.withLock { loadOrFetchEventEventIdUnderlyingReceivedEventId } }
|
|
set { loadOrFetchEventEventIdReceivedEventIdLock.withLock { loadOrFetchEventEventIdUnderlyingReceivedEventId = newValue } }
|
|
}
|
|
private let loadOrFetchEventEventIdReceivedInvocationsLock = NSLock()
|
|
private var loadOrFetchEventEventIdUnderlyingReceivedInvocations: [String] = []
|
|
open var loadOrFetchEventEventIdReceivedInvocations: [String] {
|
|
get { loadOrFetchEventEventIdReceivedInvocationsLock.withLock { loadOrFetchEventEventIdUnderlyingReceivedInvocations } }
|
|
set { loadOrFetchEventEventIdReceivedInvocationsLock.withLock { loadOrFetchEventEventIdUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let loadOrFetchEventEventIdReturnValueLock = NSLock()
|
|
open var loadOrFetchEventEventIdUnderlyingReturnValue: TimelineEvent!
|
|
open var loadOrFetchEventEventIdReturnValue: TimelineEvent! {
|
|
get { loadOrFetchEventEventIdReturnValueLock.withLock { loadOrFetchEventEventIdUnderlyingReturnValue } }
|
|
set { loadOrFetchEventEventIdReturnValueLock.withLock { loadOrFetchEventEventIdUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var loadOrFetchEventEventIdClosure: ((String) async throws -> TimelineEvent)?
|
|
|
|
open override func loadOrFetchEvent(eventId: String) async throws -> TimelineEvent {
|
|
if let error = loadOrFetchEventEventIdThrowableError {
|
|
throw error
|
|
}
|
|
loadOrFetchEventEventIdCallsCountLock.withLock { loadOrFetchEventEventIdUnderlyingCallsCount += 1 }
|
|
loadOrFetchEventEventIdReceivedEventId = eventId
|
|
loadOrFetchEventEventIdReceivedInvocationsLock.withLock { loadOrFetchEventEventIdUnderlyingReceivedInvocations.append(eventId) }
|
|
if let loadOrFetchEventEventIdClosure = loadOrFetchEventEventIdClosure {
|
|
return try await loadOrFetchEventEventIdClosure(eventId)
|
|
} else {
|
|
return loadOrFetchEventEventIdReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - markAsFullyReadUnchecked
|
|
|
|
open var markAsFullyReadUncheckedEventIdThrowableError: Error?
|
|
private let markAsFullyReadUncheckedEventIdCallsCountLock = NSLock()
|
|
private var markAsFullyReadUncheckedEventIdUnderlyingCallsCount = 0
|
|
open var markAsFullyReadUncheckedEventIdCallsCount: Int {
|
|
get { markAsFullyReadUncheckedEventIdCallsCountLock.withLock { markAsFullyReadUncheckedEventIdUnderlyingCallsCount } }
|
|
set { markAsFullyReadUncheckedEventIdCallsCountLock.withLock { markAsFullyReadUncheckedEventIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var markAsFullyReadUncheckedEventIdCalled: Bool {
|
|
return markAsFullyReadUncheckedEventIdCallsCount > 0
|
|
}
|
|
private let markAsFullyReadUncheckedEventIdReceivedEventIdLock = NSLock()
|
|
private var markAsFullyReadUncheckedEventIdUnderlyingReceivedEventId: String?
|
|
open var markAsFullyReadUncheckedEventIdReceivedEventId: String? {
|
|
get { markAsFullyReadUncheckedEventIdReceivedEventIdLock.withLock { markAsFullyReadUncheckedEventIdUnderlyingReceivedEventId } }
|
|
set { markAsFullyReadUncheckedEventIdReceivedEventIdLock.withLock { markAsFullyReadUncheckedEventIdUnderlyingReceivedEventId = newValue } }
|
|
}
|
|
private let markAsFullyReadUncheckedEventIdReceivedInvocationsLock = NSLock()
|
|
private var markAsFullyReadUncheckedEventIdUnderlyingReceivedInvocations: [String] = []
|
|
open var markAsFullyReadUncheckedEventIdReceivedInvocations: [String] {
|
|
get { markAsFullyReadUncheckedEventIdReceivedInvocationsLock.withLock { markAsFullyReadUncheckedEventIdUnderlyingReceivedInvocations } }
|
|
set { markAsFullyReadUncheckedEventIdReceivedInvocationsLock.withLock { markAsFullyReadUncheckedEventIdUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var markAsFullyReadUncheckedEventIdClosure: ((String) async throws -> Void)?
|
|
|
|
open override func markAsFullyReadUnchecked(eventId: String) async throws {
|
|
if let error = markAsFullyReadUncheckedEventIdThrowableError {
|
|
throw error
|
|
}
|
|
markAsFullyReadUncheckedEventIdCallsCountLock.withLock { markAsFullyReadUncheckedEventIdUnderlyingCallsCount += 1 }
|
|
markAsFullyReadUncheckedEventIdReceivedEventId = eventId
|
|
markAsFullyReadUncheckedEventIdReceivedInvocationsLock.withLock { markAsFullyReadUncheckedEventIdUnderlyingReceivedInvocations.append(eventId) }
|
|
try await markAsFullyReadUncheckedEventIdClosure?(eventId)
|
|
}
|
|
|
|
//MARK: - markAsRead
|
|
|
|
open var markAsReadReceiptTypeThrowableError: Error?
|
|
private let markAsReadReceiptTypeCallsCountLock = NSLock()
|
|
private var markAsReadReceiptTypeUnderlyingCallsCount = 0
|
|
open var markAsReadReceiptTypeCallsCount: Int {
|
|
get { markAsReadReceiptTypeCallsCountLock.withLock { markAsReadReceiptTypeUnderlyingCallsCount } }
|
|
set { markAsReadReceiptTypeCallsCountLock.withLock { markAsReadReceiptTypeUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var markAsReadReceiptTypeCalled: Bool {
|
|
return markAsReadReceiptTypeCallsCount > 0
|
|
}
|
|
private let markAsReadReceiptTypeReceivedReceiptTypeLock = NSLock()
|
|
private var markAsReadReceiptTypeUnderlyingReceivedReceiptType: ReceiptType?
|
|
open var markAsReadReceiptTypeReceivedReceiptType: ReceiptType? {
|
|
get { markAsReadReceiptTypeReceivedReceiptTypeLock.withLock { markAsReadReceiptTypeUnderlyingReceivedReceiptType } }
|
|
set { markAsReadReceiptTypeReceivedReceiptTypeLock.withLock { markAsReadReceiptTypeUnderlyingReceivedReceiptType = newValue } }
|
|
}
|
|
private let markAsReadReceiptTypeReceivedInvocationsLock = NSLock()
|
|
private var markAsReadReceiptTypeUnderlyingReceivedInvocations: [ReceiptType] = []
|
|
open var markAsReadReceiptTypeReceivedInvocations: [ReceiptType] {
|
|
get { markAsReadReceiptTypeReceivedInvocationsLock.withLock { markAsReadReceiptTypeUnderlyingReceivedInvocations } }
|
|
set { markAsReadReceiptTypeReceivedInvocationsLock.withLock { markAsReadReceiptTypeUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var markAsReadReceiptTypeClosure: ((ReceiptType) async throws -> Void)?
|
|
|
|
open override func markAsRead(receiptType: ReceiptType) async throws {
|
|
if let error = markAsReadReceiptTypeThrowableError {
|
|
throw error
|
|
}
|
|
markAsReadReceiptTypeCallsCountLock.withLock { markAsReadReceiptTypeUnderlyingCallsCount += 1 }
|
|
markAsReadReceiptTypeReceivedReceiptType = receiptType
|
|
markAsReadReceiptTypeReceivedInvocationsLock.withLock { markAsReadReceiptTypeUnderlyingReceivedInvocations.append(receiptType) }
|
|
try await markAsReadReceiptTypeClosure?(receiptType)
|
|
}
|
|
|
|
//MARK: - matrixToEventPermalink
|
|
|
|
open var matrixToEventPermalinkEventIdThrowableError: Error?
|
|
private let matrixToEventPermalinkEventIdCallsCountLock = NSLock()
|
|
private var matrixToEventPermalinkEventIdUnderlyingCallsCount = 0
|
|
open var matrixToEventPermalinkEventIdCallsCount: Int {
|
|
get { matrixToEventPermalinkEventIdCallsCountLock.withLock { matrixToEventPermalinkEventIdUnderlyingCallsCount } }
|
|
set { matrixToEventPermalinkEventIdCallsCountLock.withLock { matrixToEventPermalinkEventIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var matrixToEventPermalinkEventIdCalled: Bool {
|
|
return matrixToEventPermalinkEventIdCallsCount > 0
|
|
}
|
|
private let matrixToEventPermalinkEventIdReceivedEventIdLock = NSLock()
|
|
private var matrixToEventPermalinkEventIdUnderlyingReceivedEventId: String?
|
|
open var matrixToEventPermalinkEventIdReceivedEventId: String? {
|
|
get { matrixToEventPermalinkEventIdReceivedEventIdLock.withLock { matrixToEventPermalinkEventIdUnderlyingReceivedEventId } }
|
|
set { matrixToEventPermalinkEventIdReceivedEventIdLock.withLock { matrixToEventPermalinkEventIdUnderlyingReceivedEventId = newValue } }
|
|
}
|
|
private let matrixToEventPermalinkEventIdReceivedInvocationsLock = NSLock()
|
|
private var matrixToEventPermalinkEventIdUnderlyingReceivedInvocations: [String] = []
|
|
open var matrixToEventPermalinkEventIdReceivedInvocations: [String] {
|
|
get { matrixToEventPermalinkEventIdReceivedInvocationsLock.withLock { matrixToEventPermalinkEventIdUnderlyingReceivedInvocations } }
|
|
set { matrixToEventPermalinkEventIdReceivedInvocationsLock.withLock { matrixToEventPermalinkEventIdUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let matrixToEventPermalinkEventIdReturnValueLock = NSLock()
|
|
open var matrixToEventPermalinkEventIdUnderlyingReturnValue: String!
|
|
open var matrixToEventPermalinkEventIdReturnValue: String! {
|
|
get { matrixToEventPermalinkEventIdReturnValueLock.withLock { matrixToEventPermalinkEventIdUnderlyingReturnValue } }
|
|
set { matrixToEventPermalinkEventIdReturnValueLock.withLock { matrixToEventPermalinkEventIdUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var matrixToEventPermalinkEventIdClosure: ((String) async throws -> String)?
|
|
|
|
open override func matrixToEventPermalink(eventId: String) async throws -> String {
|
|
if let error = matrixToEventPermalinkEventIdThrowableError {
|
|
throw error
|
|
}
|
|
matrixToEventPermalinkEventIdCallsCountLock.withLock { matrixToEventPermalinkEventIdUnderlyingCallsCount += 1 }
|
|
matrixToEventPermalinkEventIdReceivedEventId = eventId
|
|
matrixToEventPermalinkEventIdReceivedInvocationsLock.withLock { matrixToEventPermalinkEventIdUnderlyingReceivedInvocations.append(eventId) }
|
|
if let matrixToEventPermalinkEventIdClosure = matrixToEventPermalinkEventIdClosure {
|
|
return try await matrixToEventPermalinkEventIdClosure(eventId)
|
|
} else {
|
|
return matrixToEventPermalinkEventIdReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - matrixToPermalink
|
|
|
|
open var matrixToPermalinkThrowableError: Error?
|
|
private let matrixToPermalinkCallsCountLock = NSLock()
|
|
private var matrixToPermalinkUnderlyingCallsCount = 0
|
|
open var matrixToPermalinkCallsCount: Int {
|
|
get { matrixToPermalinkCallsCountLock.withLock { matrixToPermalinkUnderlyingCallsCount } }
|
|
set { matrixToPermalinkCallsCountLock.withLock { matrixToPermalinkUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var matrixToPermalinkCalled: Bool {
|
|
return matrixToPermalinkCallsCount > 0
|
|
}
|
|
|
|
private let matrixToPermalinkReturnValueLock = NSLock()
|
|
open var matrixToPermalinkUnderlyingReturnValue: String!
|
|
open var matrixToPermalinkReturnValue: String! {
|
|
get { matrixToPermalinkReturnValueLock.withLock { matrixToPermalinkUnderlyingReturnValue } }
|
|
set { matrixToPermalinkReturnValueLock.withLock { matrixToPermalinkUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var matrixToPermalinkClosure: (() async throws -> String)?
|
|
|
|
open override func matrixToPermalink() async throws -> String {
|
|
if let error = matrixToPermalinkThrowableError {
|
|
throw error
|
|
}
|
|
matrixToPermalinkCallsCountLock.withLock { matrixToPermalinkUnderlyingCallsCount += 1 }
|
|
if let matrixToPermalinkClosure = matrixToPermalinkClosure {
|
|
return try await matrixToPermalinkClosure()
|
|
} else {
|
|
return matrixToPermalinkReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - member
|
|
|
|
open var memberUserIdThrowableError: Error?
|
|
private let memberUserIdCallsCountLock = NSLock()
|
|
private var memberUserIdUnderlyingCallsCount = 0
|
|
open var memberUserIdCallsCount: Int {
|
|
get { memberUserIdCallsCountLock.withLock { memberUserIdUnderlyingCallsCount } }
|
|
set { memberUserIdCallsCountLock.withLock { memberUserIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var memberUserIdCalled: Bool {
|
|
return memberUserIdCallsCount > 0
|
|
}
|
|
private let memberUserIdReceivedUserIdLock = NSLock()
|
|
private var memberUserIdUnderlyingReceivedUserId: String?
|
|
open var memberUserIdReceivedUserId: String? {
|
|
get { memberUserIdReceivedUserIdLock.withLock { memberUserIdUnderlyingReceivedUserId } }
|
|
set { memberUserIdReceivedUserIdLock.withLock { memberUserIdUnderlyingReceivedUserId = newValue } }
|
|
}
|
|
private let memberUserIdReceivedInvocationsLock = NSLock()
|
|
private var memberUserIdUnderlyingReceivedInvocations: [String] = []
|
|
open var memberUserIdReceivedInvocations: [String] {
|
|
get { memberUserIdReceivedInvocationsLock.withLock { memberUserIdUnderlyingReceivedInvocations } }
|
|
set { memberUserIdReceivedInvocationsLock.withLock { memberUserIdUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let memberUserIdReturnValueLock = NSLock()
|
|
open var memberUserIdUnderlyingReturnValue: RoomMember!
|
|
open var memberUserIdReturnValue: RoomMember! {
|
|
get { memberUserIdReturnValueLock.withLock { memberUserIdUnderlyingReturnValue } }
|
|
set { memberUserIdReturnValueLock.withLock { memberUserIdUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var memberUserIdClosure: ((String) async throws -> RoomMember)?
|
|
|
|
open override func member(userId: String) async throws -> RoomMember {
|
|
if let error = memberUserIdThrowableError {
|
|
throw error
|
|
}
|
|
memberUserIdCallsCountLock.withLock { memberUserIdUnderlyingCallsCount += 1 }
|
|
memberUserIdReceivedUserId = userId
|
|
memberUserIdReceivedInvocationsLock.withLock { memberUserIdUnderlyingReceivedInvocations.append(userId) }
|
|
if let memberUserIdClosure = memberUserIdClosure {
|
|
return try await memberUserIdClosure(userId)
|
|
} else {
|
|
return memberUserIdReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - memberAvatarUrl
|
|
|
|
open var memberAvatarUrlUserIdThrowableError: Error?
|
|
private let memberAvatarUrlUserIdCallsCountLock = NSLock()
|
|
private var memberAvatarUrlUserIdUnderlyingCallsCount = 0
|
|
open var memberAvatarUrlUserIdCallsCount: Int {
|
|
get { memberAvatarUrlUserIdCallsCountLock.withLock { memberAvatarUrlUserIdUnderlyingCallsCount } }
|
|
set { memberAvatarUrlUserIdCallsCountLock.withLock { memberAvatarUrlUserIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var memberAvatarUrlUserIdCalled: Bool {
|
|
return memberAvatarUrlUserIdCallsCount > 0
|
|
}
|
|
private let memberAvatarUrlUserIdReceivedUserIdLock = NSLock()
|
|
private var memberAvatarUrlUserIdUnderlyingReceivedUserId: String?
|
|
open var memberAvatarUrlUserIdReceivedUserId: String? {
|
|
get { memberAvatarUrlUserIdReceivedUserIdLock.withLock { memberAvatarUrlUserIdUnderlyingReceivedUserId } }
|
|
set { memberAvatarUrlUserIdReceivedUserIdLock.withLock { memberAvatarUrlUserIdUnderlyingReceivedUserId = newValue } }
|
|
}
|
|
private let memberAvatarUrlUserIdReceivedInvocationsLock = NSLock()
|
|
private var memberAvatarUrlUserIdUnderlyingReceivedInvocations: [String] = []
|
|
open var memberAvatarUrlUserIdReceivedInvocations: [String] {
|
|
get { memberAvatarUrlUserIdReceivedInvocationsLock.withLock { memberAvatarUrlUserIdUnderlyingReceivedInvocations } }
|
|
set { memberAvatarUrlUserIdReceivedInvocationsLock.withLock { memberAvatarUrlUserIdUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let memberAvatarUrlUserIdReturnValueLock = NSLock()
|
|
open var memberAvatarUrlUserIdUnderlyingReturnValue: String?
|
|
open var memberAvatarUrlUserIdReturnValue: String? {
|
|
get { memberAvatarUrlUserIdReturnValueLock.withLock { memberAvatarUrlUserIdUnderlyingReturnValue } }
|
|
set { memberAvatarUrlUserIdReturnValueLock.withLock { memberAvatarUrlUserIdUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var memberAvatarUrlUserIdClosure: ((String) async throws -> String?)?
|
|
|
|
open override func memberAvatarUrl(userId: String) async throws -> String? {
|
|
if let error = memberAvatarUrlUserIdThrowableError {
|
|
throw error
|
|
}
|
|
memberAvatarUrlUserIdCallsCountLock.withLock { memberAvatarUrlUserIdUnderlyingCallsCount += 1 }
|
|
memberAvatarUrlUserIdReceivedUserId = userId
|
|
memberAvatarUrlUserIdReceivedInvocationsLock.withLock { memberAvatarUrlUserIdUnderlyingReceivedInvocations.append(userId) }
|
|
if let memberAvatarUrlUserIdClosure = memberAvatarUrlUserIdClosure {
|
|
return try await memberAvatarUrlUserIdClosure(userId)
|
|
} else {
|
|
return memberAvatarUrlUserIdReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - memberDisplayName
|
|
|
|
open var memberDisplayNameUserIdThrowableError: Error?
|
|
private let memberDisplayNameUserIdCallsCountLock = NSLock()
|
|
private var memberDisplayNameUserIdUnderlyingCallsCount = 0
|
|
open var memberDisplayNameUserIdCallsCount: Int {
|
|
get { memberDisplayNameUserIdCallsCountLock.withLock { memberDisplayNameUserIdUnderlyingCallsCount } }
|
|
set { memberDisplayNameUserIdCallsCountLock.withLock { memberDisplayNameUserIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var memberDisplayNameUserIdCalled: Bool {
|
|
return memberDisplayNameUserIdCallsCount > 0
|
|
}
|
|
private let memberDisplayNameUserIdReceivedUserIdLock = NSLock()
|
|
private var memberDisplayNameUserIdUnderlyingReceivedUserId: String?
|
|
open var memberDisplayNameUserIdReceivedUserId: String? {
|
|
get { memberDisplayNameUserIdReceivedUserIdLock.withLock { memberDisplayNameUserIdUnderlyingReceivedUserId } }
|
|
set { memberDisplayNameUserIdReceivedUserIdLock.withLock { memberDisplayNameUserIdUnderlyingReceivedUserId = newValue } }
|
|
}
|
|
private let memberDisplayNameUserIdReceivedInvocationsLock = NSLock()
|
|
private var memberDisplayNameUserIdUnderlyingReceivedInvocations: [String] = []
|
|
open var memberDisplayNameUserIdReceivedInvocations: [String] {
|
|
get { memberDisplayNameUserIdReceivedInvocationsLock.withLock { memberDisplayNameUserIdUnderlyingReceivedInvocations } }
|
|
set { memberDisplayNameUserIdReceivedInvocationsLock.withLock { memberDisplayNameUserIdUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let memberDisplayNameUserIdReturnValueLock = NSLock()
|
|
open var memberDisplayNameUserIdUnderlyingReturnValue: String?
|
|
open var memberDisplayNameUserIdReturnValue: String? {
|
|
get { memberDisplayNameUserIdReturnValueLock.withLock { memberDisplayNameUserIdUnderlyingReturnValue } }
|
|
set { memberDisplayNameUserIdReturnValueLock.withLock { memberDisplayNameUserIdUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var memberDisplayNameUserIdClosure: ((String) async throws -> String?)?
|
|
|
|
open override func memberDisplayName(userId: String) async throws -> String? {
|
|
if let error = memberDisplayNameUserIdThrowableError {
|
|
throw error
|
|
}
|
|
memberDisplayNameUserIdCallsCountLock.withLock { memberDisplayNameUserIdUnderlyingCallsCount += 1 }
|
|
memberDisplayNameUserIdReceivedUserId = userId
|
|
memberDisplayNameUserIdReceivedInvocationsLock.withLock { memberDisplayNameUserIdUnderlyingReceivedInvocations.append(userId) }
|
|
if let memberDisplayNameUserIdClosure = memberDisplayNameUserIdClosure {
|
|
return try await memberDisplayNameUserIdClosure(userId)
|
|
} else {
|
|
return memberDisplayNameUserIdReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - memberWithSenderInfo
|
|
|
|
open var memberWithSenderInfoUserIdThrowableError: Error?
|
|
private let memberWithSenderInfoUserIdCallsCountLock = NSLock()
|
|
private var memberWithSenderInfoUserIdUnderlyingCallsCount = 0
|
|
open var memberWithSenderInfoUserIdCallsCount: Int {
|
|
get { memberWithSenderInfoUserIdCallsCountLock.withLock { memberWithSenderInfoUserIdUnderlyingCallsCount } }
|
|
set { memberWithSenderInfoUserIdCallsCountLock.withLock { memberWithSenderInfoUserIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var memberWithSenderInfoUserIdCalled: Bool {
|
|
return memberWithSenderInfoUserIdCallsCount > 0
|
|
}
|
|
private let memberWithSenderInfoUserIdReceivedUserIdLock = NSLock()
|
|
private var memberWithSenderInfoUserIdUnderlyingReceivedUserId: String?
|
|
open var memberWithSenderInfoUserIdReceivedUserId: String? {
|
|
get { memberWithSenderInfoUserIdReceivedUserIdLock.withLock { memberWithSenderInfoUserIdUnderlyingReceivedUserId } }
|
|
set { memberWithSenderInfoUserIdReceivedUserIdLock.withLock { memberWithSenderInfoUserIdUnderlyingReceivedUserId = newValue } }
|
|
}
|
|
private let memberWithSenderInfoUserIdReceivedInvocationsLock = NSLock()
|
|
private var memberWithSenderInfoUserIdUnderlyingReceivedInvocations: [String] = []
|
|
open var memberWithSenderInfoUserIdReceivedInvocations: [String] {
|
|
get { memberWithSenderInfoUserIdReceivedInvocationsLock.withLock { memberWithSenderInfoUserIdUnderlyingReceivedInvocations } }
|
|
set { memberWithSenderInfoUserIdReceivedInvocationsLock.withLock { memberWithSenderInfoUserIdUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let memberWithSenderInfoUserIdReturnValueLock = NSLock()
|
|
open var memberWithSenderInfoUserIdUnderlyingReturnValue: RoomMemberWithSenderInfo!
|
|
open var memberWithSenderInfoUserIdReturnValue: RoomMemberWithSenderInfo! {
|
|
get { memberWithSenderInfoUserIdReturnValueLock.withLock { memberWithSenderInfoUserIdUnderlyingReturnValue } }
|
|
set { memberWithSenderInfoUserIdReturnValueLock.withLock { memberWithSenderInfoUserIdUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var memberWithSenderInfoUserIdClosure: ((String) async throws -> RoomMemberWithSenderInfo)?
|
|
|
|
open override func memberWithSenderInfo(userId: String) async throws -> RoomMemberWithSenderInfo {
|
|
if let error = memberWithSenderInfoUserIdThrowableError {
|
|
throw error
|
|
}
|
|
memberWithSenderInfoUserIdCallsCountLock.withLock { memberWithSenderInfoUserIdUnderlyingCallsCount += 1 }
|
|
memberWithSenderInfoUserIdReceivedUserId = userId
|
|
memberWithSenderInfoUserIdReceivedInvocationsLock.withLock { memberWithSenderInfoUserIdUnderlyingReceivedInvocations.append(userId) }
|
|
if let memberWithSenderInfoUserIdClosure = memberWithSenderInfoUserIdClosure {
|
|
return try await memberWithSenderInfoUserIdClosure(userId)
|
|
} else {
|
|
return memberWithSenderInfoUserIdReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - members
|
|
|
|
open var membersThrowableError: Error?
|
|
private let membersCallsCountLock = NSLock()
|
|
private var membersUnderlyingCallsCount = 0
|
|
open var membersCallsCount: Int {
|
|
get { membersCallsCountLock.withLock { membersUnderlyingCallsCount } }
|
|
set { membersCallsCountLock.withLock { membersUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var membersCalled: Bool {
|
|
return membersCallsCount > 0
|
|
}
|
|
|
|
private let membersReturnValueLock = NSLock()
|
|
open var membersUnderlyingReturnValue: RoomMembersIterator!
|
|
open var membersReturnValue: RoomMembersIterator! {
|
|
get { membersReturnValueLock.withLock { membersUnderlyingReturnValue } }
|
|
set { membersReturnValueLock.withLock { membersUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var membersClosure: (() async throws -> RoomMembersIterator)?
|
|
|
|
open override func members() async throws -> RoomMembersIterator {
|
|
if let error = membersThrowableError {
|
|
throw error
|
|
}
|
|
membersCallsCountLock.withLock { membersUnderlyingCallsCount += 1 }
|
|
if let membersClosure = membersClosure {
|
|
return try await membersClosure()
|
|
} else {
|
|
return membersReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - membersNoSync
|
|
|
|
open var membersNoSyncThrowableError: Error?
|
|
private let membersNoSyncCallsCountLock = NSLock()
|
|
private var membersNoSyncUnderlyingCallsCount = 0
|
|
open var membersNoSyncCallsCount: Int {
|
|
get { membersNoSyncCallsCountLock.withLock { membersNoSyncUnderlyingCallsCount } }
|
|
set { membersNoSyncCallsCountLock.withLock { membersNoSyncUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var membersNoSyncCalled: Bool {
|
|
return membersNoSyncCallsCount > 0
|
|
}
|
|
|
|
private let membersNoSyncReturnValueLock = NSLock()
|
|
open var membersNoSyncUnderlyingReturnValue: RoomMembersIterator!
|
|
open var membersNoSyncReturnValue: RoomMembersIterator! {
|
|
get { membersNoSyncReturnValueLock.withLock { membersNoSyncUnderlyingReturnValue } }
|
|
set { membersNoSyncReturnValueLock.withLock { membersNoSyncUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var membersNoSyncClosure: (() async throws -> RoomMembersIterator)?
|
|
|
|
open override func membersNoSync() async throws -> RoomMembersIterator {
|
|
if let error = membersNoSyncThrowableError {
|
|
throw error
|
|
}
|
|
membersNoSyncCallsCountLock.withLock { membersNoSyncUnderlyingCallsCount += 1 }
|
|
if let membersNoSyncClosure = membersNoSyncClosure {
|
|
return try await membersNoSyncClosure()
|
|
} else {
|
|
return membersNoSyncReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - membership
|
|
|
|
private let membershipCallsCountLock = NSLock()
|
|
private var membershipUnderlyingCallsCount = 0
|
|
open var membershipCallsCount: Int {
|
|
get { membershipCallsCountLock.withLock { membershipUnderlyingCallsCount } }
|
|
set { membershipCallsCountLock.withLock { membershipUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var membershipCalled: Bool {
|
|
return membershipCallsCount > 0
|
|
}
|
|
|
|
private let membershipReturnValueLock = NSLock()
|
|
open var membershipUnderlyingReturnValue: Membership!
|
|
open var membershipReturnValue: Membership! {
|
|
get { membershipReturnValueLock.withLock { membershipUnderlyingReturnValue } }
|
|
set { membershipReturnValueLock.withLock { membershipUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var membershipClosure: (() -> Membership)?
|
|
|
|
open override func membership() -> Membership {
|
|
membershipCallsCountLock.withLock { membershipUnderlyingCallsCount += 1 }
|
|
if let membershipClosure = membershipClosure {
|
|
return membershipClosure()
|
|
} else {
|
|
return membershipReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - ownUserId
|
|
|
|
private let ownUserIdCallsCountLock = NSLock()
|
|
private var ownUserIdUnderlyingCallsCount = 0
|
|
open var ownUserIdCallsCount: Int {
|
|
get { ownUserIdCallsCountLock.withLock { ownUserIdUnderlyingCallsCount } }
|
|
set { ownUserIdCallsCountLock.withLock { ownUserIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var ownUserIdCalled: Bool {
|
|
return ownUserIdCallsCount > 0
|
|
}
|
|
|
|
private let ownUserIdReturnValueLock = NSLock()
|
|
open var ownUserIdUnderlyingReturnValue: String!
|
|
open var ownUserIdReturnValue: String! {
|
|
get { ownUserIdReturnValueLock.withLock { ownUserIdUnderlyingReturnValue } }
|
|
set { ownUserIdReturnValueLock.withLock { ownUserIdUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var ownUserIdClosure: (() -> String)?
|
|
|
|
open override func ownUserId() -> String {
|
|
ownUserIdCallsCountLock.withLock { ownUserIdUnderlyingCallsCount += 1 }
|
|
if let ownUserIdClosure = ownUserIdClosure {
|
|
return ownUserIdClosure()
|
|
} else {
|
|
return ownUserIdReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - predecessorRoom
|
|
|
|
private let predecessorRoomCallsCountLock = NSLock()
|
|
private var predecessorRoomUnderlyingCallsCount = 0
|
|
open var predecessorRoomCallsCount: Int {
|
|
get { predecessorRoomCallsCountLock.withLock { predecessorRoomUnderlyingCallsCount } }
|
|
set { predecessorRoomCallsCountLock.withLock { predecessorRoomUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var predecessorRoomCalled: Bool {
|
|
return predecessorRoomCallsCount > 0
|
|
}
|
|
|
|
private let predecessorRoomReturnValueLock = NSLock()
|
|
open var predecessorRoomUnderlyingReturnValue: PredecessorRoom?
|
|
open var predecessorRoomReturnValue: PredecessorRoom? {
|
|
get { predecessorRoomReturnValueLock.withLock { predecessorRoomUnderlyingReturnValue } }
|
|
set { predecessorRoomReturnValueLock.withLock { predecessorRoomUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var predecessorRoomClosure: (() -> PredecessorRoom?)?
|
|
|
|
open override func predecessorRoom() -> PredecessorRoom? {
|
|
predecessorRoomCallsCountLock.withLock { predecessorRoomUnderlyingCallsCount += 1 }
|
|
if let predecessorRoomClosure = predecessorRoomClosure {
|
|
return predecessorRoomClosure()
|
|
} else {
|
|
return predecessorRoomReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - previewRoom
|
|
|
|
open var previewRoomViaThrowableError: Error?
|
|
private let previewRoomViaCallsCountLock = NSLock()
|
|
private var previewRoomViaUnderlyingCallsCount = 0
|
|
open var previewRoomViaCallsCount: Int {
|
|
get { previewRoomViaCallsCountLock.withLock { previewRoomViaUnderlyingCallsCount } }
|
|
set { previewRoomViaCallsCountLock.withLock { previewRoomViaUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var previewRoomViaCalled: Bool {
|
|
return previewRoomViaCallsCount > 0
|
|
}
|
|
private let previewRoomViaReceivedViaLock = NSLock()
|
|
private var previewRoomViaUnderlyingReceivedVia: [String]?
|
|
open var previewRoomViaReceivedVia: [String]? {
|
|
get { previewRoomViaReceivedViaLock.withLock { previewRoomViaUnderlyingReceivedVia } }
|
|
set { previewRoomViaReceivedViaLock.withLock { previewRoomViaUnderlyingReceivedVia = newValue } }
|
|
}
|
|
private let previewRoomViaReceivedInvocationsLock = NSLock()
|
|
private var previewRoomViaUnderlyingReceivedInvocations: [[String]] = []
|
|
open var previewRoomViaReceivedInvocations: [[String]] {
|
|
get { previewRoomViaReceivedInvocationsLock.withLock { previewRoomViaUnderlyingReceivedInvocations } }
|
|
set { previewRoomViaReceivedInvocationsLock.withLock { previewRoomViaUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let previewRoomViaReturnValueLock = NSLock()
|
|
open var previewRoomViaUnderlyingReturnValue: RoomPreview!
|
|
open var previewRoomViaReturnValue: RoomPreview! {
|
|
get { previewRoomViaReturnValueLock.withLock { previewRoomViaUnderlyingReturnValue } }
|
|
set { previewRoomViaReturnValueLock.withLock { previewRoomViaUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var previewRoomViaClosure: (([String]) async throws -> RoomPreview)?
|
|
|
|
open override func previewRoom(via: [String]) async throws -> RoomPreview {
|
|
if let error = previewRoomViaThrowableError {
|
|
throw error
|
|
}
|
|
previewRoomViaCallsCountLock.withLock { previewRoomViaUnderlyingCallsCount += 1 }
|
|
previewRoomViaReceivedVia = via
|
|
previewRoomViaReceivedInvocationsLock.withLock { previewRoomViaUnderlyingReceivedInvocations.append(via) }
|
|
if let previewRoomViaClosure = previewRoomViaClosure {
|
|
return try await previewRoomViaClosure(via)
|
|
} else {
|
|
return previewRoomViaReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - publishRoomAliasInRoomDirectory
|
|
|
|
open var publishRoomAliasInRoomDirectoryAliasThrowableError: Error?
|
|
private let publishRoomAliasInRoomDirectoryAliasCallsCountLock = NSLock()
|
|
private var publishRoomAliasInRoomDirectoryAliasUnderlyingCallsCount = 0
|
|
open var publishRoomAliasInRoomDirectoryAliasCallsCount: Int {
|
|
get { publishRoomAliasInRoomDirectoryAliasCallsCountLock.withLock { publishRoomAliasInRoomDirectoryAliasUnderlyingCallsCount } }
|
|
set { publishRoomAliasInRoomDirectoryAliasCallsCountLock.withLock { publishRoomAliasInRoomDirectoryAliasUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var publishRoomAliasInRoomDirectoryAliasCalled: Bool {
|
|
return publishRoomAliasInRoomDirectoryAliasCallsCount > 0
|
|
}
|
|
private let publishRoomAliasInRoomDirectoryAliasReceivedAliasLock = NSLock()
|
|
private var publishRoomAliasInRoomDirectoryAliasUnderlyingReceivedAlias: String?
|
|
open var publishRoomAliasInRoomDirectoryAliasReceivedAlias: String? {
|
|
get { publishRoomAliasInRoomDirectoryAliasReceivedAliasLock.withLock { publishRoomAliasInRoomDirectoryAliasUnderlyingReceivedAlias } }
|
|
set { publishRoomAliasInRoomDirectoryAliasReceivedAliasLock.withLock { publishRoomAliasInRoomDirectoryAliasUnderlyingReceivedAlias = newValue } }
|
|
}
|
|
private let publishRoomAliasInRoomDirectoryAliasReceivedInvocationsLock = NSLock()
|
|
private var publishRoomAliasInRoomDirectoryAliasUnderlyingReceivedInvocations: [String] = []
|
|
open var publishRoomAliasInRoomDirectoryAliasReceivedInvocations: [String] {
|
|
get { publishRoomAliasInRoomDirectoryAliasReceivedInvocationsLock.withLock { publishRoomAliasInRoomDirectoryAliasUnderlyingReceivedInvocations } }
|
|
set { publishRoomAliasInRoomDirectoryAliasReceivedInvocationsLock.withLock { publishRoomAliasInRoomDirectoryAliasUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let publishRoomAliasInRoomDirectoryAliasReturnValueLock = NSLock()
|
|
open var publishRoomAliasInRoomDirectoryAliasUnderlyingReturnValue: Bool!
|
|
open var publishRoomAliasInRoomDirectoryAliasReturnValue: Bool! {
|
|
get { publishRoomAliasInRoomDirectoryAliasReturnValueLock.withLock { publishRoomAliasInRoomDirectoryAliasUnderlyingReturnValue } }
|
|
set { publishRoomAliasInRoomDirectoryAliasReturnValueLock.withLock { publishRoomAliasInRoomDirectoryAliasUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var publishRoomAliasInRoomDirectoryAliasClosure: ((String) async throws -> Bool)?
|
|
|
|
open override func publishRoomAliasInRoomDirectory(alias: String) async throws -> Bool {
|
|
if let error = publishRoomAliasInRoomDirectoryAliasThrowableError {
|
|
throw error
|
|
}
|
|
publishRoomAliasInRoomDirectoryAliasCallsCountLock.withLock { publishRoomAliasInRoomDirectoryAliasUnderlyingCallsCount += 1 }
|
|
publishRoomAliasInRoomDirectoryAliasReceivedAlias = alias
|
|
publishRoomAliasInRoomDirectoryAliasReceivedInvocationsLock.withLock { publishRoomAliasInRoomDirectoryAliasUnderlyingReceivedInvocations.append(alias) }
|
|
if let publishRoomAliasInRoomDirectoryAliasClosure = publishRoomAliasInRoomDirectoryAliasClosure {
|
|
return try await publishRoomAliasInRoomDirectoryAliasClosure(alias)
|
|
} else {
|
|
return publishRoomAliasInRoomDirectoryAliasReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - rawName
|
|
|
|
private let rawNameCallsCountLock = NSLock()
|
|
private var rawNameUnderlyingCallsCount = 0
|
|
open var rawNameCallsCount: Int {
|
|
get { rawNameCallsCountLock.withLock { rawNameUnderlyingCallsCount } }
|
|
set { rawNameCallsCountLock.withLock { rawNameUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var rawNameCalled: Bool {
|
|
return rawNameCallsCount > 0
|
|
}
|
|
|
|
private let rawNameReturnValueLock = NSLock()
|
|
open var rawNameUnderlyingReturnValue: String?
|
|
open var rawNameReturnValue: String? {
|
|
get { rawNameReturnValueLock.withLock { rawNameUnderlyingReturnValue } }
|
|
set { rawNameReturnValueLock.withLock { rawNameUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var rawNameClosure: (() -> String?)?
|
|
|
|
open override func rawName() -> String? {
|
|
rawNameCallsCountLock.withLock { rawNameUnderlyingCallsCount += 1 }
|
|
if let rawNameClosure = rawNameClosure {
|
|
return rawNameClosure()
|
|
} else {
|
|
return rawNameReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - redact
|
|
|
|
open var redactEventIdReasonThrowableError: Error?
|
|
private let redactEventIdReasonCallsCountLock = NSLock()
|
|
private var redactEventIdReasonUnderlyingCallsCount = 0
|
|
open var redactEventIdReasonCallsCount: Int {
|
|
get { redactEventIdReasonCallsCountLock.withLock { redactEventIdReasonUnderlyingCallsCount } }
|
|
set { redactEventIdReasonCallsCountLock.withLock { redactEventIdReasonUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var redactEventIdReasonCalled: Bool {
|
|
return redactEventIdReasonCallsCount > 0
|
|
}
|
|
private let redactEventIdReasonReceivedArgumentsLock = NSLock()
|
|
private var redactEventIdReasonUnderlyingReceivedArguments: (eventId: String, reason: String?)?
|
|
open var redactEventIdReasonReceivedArguments: (eventId: String, reason: String?)? {
|
|
get { redactEventIdReasonReceivedArgumentsLock.withLock { redactEventIdReasonUnderlyingReceivedArguments } }
|
|
set { redactEventIdReasonReceivedArgumentsLock.withLock { redactEventIdReasonUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let redactEventIdReasonReceivedInvocationsLock = NSLock()
|
|
private var redactEventIdReasonUnderlyingReceivedInvocations: [(eventId: String, reason: String?)] = []
|
|
open var redactEventIdReasonReceivedInvocations: [(eventId: String, reason: String?)] {
|
|
get { redactEventIdReasonReceivedInvocationsLock.withLock { redactEventIdReasonUnderlyingReceivedInvocations } }
|
|
set { redactEventIdReasonReceivedInvocationsLock.withLock { redactEventIdReasonUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var redactEventIdReasonClosure: ((String, String?) async throws -> Void)?
|
|
|
|
open override func redact(eventId: String, reason: String?) async throws {
|
|
if let error = redactEventIdReasonThrowableError {
|
|
throw error
|
|
}
|
|
redactEventIdReasonCallsCountLock.withLock { redactEventIdReasonUnderlyingCallsCount += 1 }
|
|
redactEventIdReasonReceivedArguments = (eventId: eventId, reason: reason)
|
|
redactEventIdReasonReceivedInvocationsLock.withLock { redactEventIdReasonUnderlyingReceivedInvocations.append((eventId: eventId, reason: reason)) }
|
|
try await redactEventIdReasonClosure?(eventId, reason)
|
|
}
|
|
|
|
//MARK: - removeAvatar
|
|
|
|
open var removeAvatarThrowableError: Error?
|
|
private let removeAvatarCallsCountLock = NSLock()
|
|
private var removeAvatarUnderlyingCallsCount = 0
|
|
open var removeAvatarCallsCount: Int {
|
|
get { removeAvatarCallsCountLock.withLock { removeAvatarUnderlyingCallsCount } }
|
|
set { removeAvatarCallsCountLock.withLock { removeAvatarUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var removeAvatarCalled: Bool {
|
|
return removeAvatarCallsCount > 0
|
|
}
|
|
open var removeAvatarClosure: (() async throws -> Void)?
|
|
|
|
open override func removeAvatar() async throws {
|
|
if let error = removeAvatarThrowableError {
|
|
throw error
|
|
}
|
|
removeAvatarCallsCountLock.withLock { removeAvatarUnderlyingCallsCount += 1 }
|
|
try await removeAvatarClosure?()
|
|
}
|
|
|
|
//MARK: - removeRoomAliasFromRoomDirectory
|
|
|
|
open var removeRoomAliasFromRoomDirectoryAliasThrowableError: Error?
|
|
private let removeRoomAliasFromRoomDirectoryAliasCallsCountLock = NSLock()
|
|
private var removeRoomAliasFromRoomDirectoryAliasUnderlyingCallsCount = 0
|
|
open var removeRoomAliasFromRoomDirectoryAliasCallsCount: Int {
|
|
get { removeRoomAliasFromRoomDirectoryAliasCallsCountLock.withLock { removeRoomAliasFromRoomDirectoryAliasUnderlyingCallsCount } }
|
|
set { removeRoomAliasFromRoomDirectoryAliasCallsCountLock.withLock { removeRoomAliasFromRoomDirectoryAliasUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var removeRoomAliasFromRoomDirectoryAliasCalled: Bool {
|
|
return removeRoomAliasFromRoomDirectoryAliasCallsCount > 0
|
|
}
|
|
private let removeRoomAliasFromRoomDirectoryAliasReceivedAliasLock = NSLock()
|
|
private var removeRoomAliasFromRoomDirectoryAliasUnderlyingReceivedAlias: String?
|
|
open var removeRoomAliasFromRoomDirectoryAliasReceivedAlias: String? {
|
|
get { removeRoomAliasFromRoomDirectoryAliasReceivedAliasLock.withLock { removeRoomAliasFromRoomDirectoryAliasUnderlyingReceivedAlias } }
|
|
set { removeRoomAliasFromRoomDirectoryAliasReceivedAliasLock.withLock { removeRoomAliasFromRoomDirectoryAliasUnderlyingReceivedAlias = newValue } }
|
|
}
|
|
private let removeRoomAliasFromRoomDirectoryAliasReceivedInvocationsLock = NSLock()
|
|
private var removeRoomAliasFromRoomDirectoryAliasUnderlyingReceivedInvocations: [String] = []
|
|
open var removeRoomAliasFromRoomDirectoryAliasReceivedInvocations: [String] {
|
|
get { removeRoomAliasFromRoomDirectoryAliasReceivedInvocationsLock.withLock { removeRoomAliasFromRoomDirectoryAliasUnderlyingReceivedInvocations } }
|
|
set { removeRoomAliasFromRoomDirectoryAliasReceivedInvocationsLock.withLock { removeRoomAliasFromRoomDirectoryAliasUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let removeRoomAliasFromRoomDirectoryAliasReturnValueLock = NSLock()
|
|
open var removeRoomAliasFromRoomDirectoryAliasUnderlyingReturnValue: Bool!
|
|
open var removeRoomAliasFromRoomDirectoryAliasReturnValue: Bool! {
|
|
get { removeRoomAliasFromRoomDirectoryAliasReturnValueLock.withLock { removeRoomAliasFromRoomDirectoryAliasUnderlyingReturnValue } }
|
|
set { removeRoomAliasFromRoomDirectoryAliasReturnValueLock.withLock { removeRoomAliasFromRoomDirectoryAliasUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var removeRoomAliasFromRoomDirectoryAliasClosure: ((String) async throws -> Bool)?
|
|
|
|
open override func removeRoomAliasFromRoomDirectory(alias: String) async throws -> Bool {
|
|
if let error = removeRoomAliasFromRoomDirectoryAliasThrowableError {
|
|
throw error
|
|
}
|
|
removeRoomAliasFromRoomDirectoryAliasCallsCountLock.withLock { removeRoomAliasFromRoomDirectoryAliasUnderlyingCallsCount += 1 }
|
|
removeRoomAliasFromRoomDirectoryAliasReceivedAlias = alias
|
|
removeRoomAliasFromRoomDirectoryAliasReceivedInvocationsLock.withLock { removeRoomAliasFromRoomDirectoryAliasUnderlyingReceivedInvocations.append(alias) }
|
|
if let removeRoomAliasFromRoomDirectoryAliasClosure = removeRoomAliasFromRoomDirectoryAliasClosure {
|
|
return try await removeRoomAliasFromRoomDirectoryAliasClosure(alias)
|
|
} else {
|
|
return removeRoomAliasFromRoomDirectoryAliasReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - reportContent
|
|
|
|
open var reportContentEventIdReasonThrowableError: Error?
|
|
private let reportContentEventIdReasonCallsCountLock = NSLock()
|
|
private var reportContentEventIdReasonUnderlyingCallsCount = 0
|
|
open var reportContentEventIdReasonCallsCount: Int {
|
|
get { reportContentEventIdReasonCallsCountLock.withLock { reportContentEventIdReasonUnderlyingCallsCount } }
|
|
set { reportContentEventIdReasonCallsCountLock.withLock { reportContentEventIdReasonUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var reportContentEventIdReasonCalled: Bool {
|
|
return reportContentEventIdReasonCallsCount > 0
|
|
}
|
|
private let reportContentEventIdReasonReceivedArgumentsLock = NSLock()
|
|
private var reportContentEventIdReasonUnderlyingReceivedArguments: (eventId: String, reason: String?)?
|
|
open var reportContentEventIdReasonReceivedArguments: (eventId: String, reason: String?)? {
|
|
get { reportContentEventIdReasonReceivedArgumentsLock.withLock { reportContentEventIdReasonUnderlyingReceivedArguments } }
|
|
set { reportContentEventIdReasonReceivedArgumentsLock.withLock { reportContentEventIdReasonUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let reportContentEventIdReasonReceivedInvocationsLock = NSLock()
|
|
private var reportContentEventIdReasonUnderlyingReceivedInvocations: [(eventId: String, reason: String?)] = []
|
|
open var reportContentEventIdReasonReceivedInvocations: [(eventId: String, reason: String?)] {
|
|
get { reportContentEventIdReasonReceivedInvocationsLock.withLock { reportContentEventIdReasonUnderlyingReceivedInvocations } }
|
|
set { reportContentEventIdReasonReceivedInvocationsLock.withLock { reportContentEventIdReasonUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var reportContentEventIdReasonClosure: ((String, String?) async throws -> Void)?
|
|
|
|
open override func reportContent(eventId: String, reason: String?) async throws {
|
|
if let error = reportContentEventIdReasonThrowableError {
|
|
throw error
|
|
}
|
|
reportContentEventIdReasonCallsCountLock.withLock { reportContentEventIdReasonUnderlyingCallsCount += 1 }
|
|
reportContentEventIdReasonReceivedArguments = (eventId: eventId, reason: reason)
|
|
reportContentEventIdReasonReceivedInvocationsLock.withLock { reportContentEventIdReasonUnderlyingReceivedInvocations.append((eventId: eventId, reason: reason)) }
|
|
try await reportContentEventIdReasonClosure?(eventId, reason)
|
|
}
|
|
|
|
//MARK: - reportRoom
|
|
|
|
open var reportRoomReasonThrowableError: Error?
|
|
private let reportRoomReasonCallsCountLock = NSLock()
|
|
private var reportRoomReasonUnderlyingCallsCount = 0
|
|
open var reportRoomReasonCallsCount: Int {
|
|
get { reportRoomReasonCallsCountLock.withLock { reportRoomReasonUnderlyingCallsCount } }
|
|
set { reportRoomReasonCallsCountLock.withLock { reportRoomReasonUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var reportRoomReasonCalled: Bool {
|
|
return reportRoomReasonCallsCount > 0
|
|
}
|
|
private let reportRoomReasonReceivedReasonLock = NSLock()
|
|
private var reportRoomReasonUnderlyingReceivedReason: String?
|
|
open var reportRoomReasonReceivedReason: String? {
|
|
get { reportRoomReasonReceivedReasonLock.withLock { reportRoomReasonUnderlyingReceivedReason } }
|
|
set { reportRoomReasonReceivedReasonLock.withLock { reportRoomReasonUnderlyingReceivedReason = newValue } }
|
|
}
|
|
private let reportRoomReasonReceivedInvocationsLock = NSLock()
|
|
private var reportRoomReasonUnderlyingReceivedInvocations: [String] = []
|
|
open var reportRoomReasonReceivedInvocations: [String] {
|
|
get { reportRoomReasonReceivedInvocationsLock.withLock { reportRoomReasonUnderlyingReceivedInvocations } }
|
|
set { reportRoomReasonReceivedInvocationsLock.withLock { reportRoomReasonUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var reportRoomReasonClosure: ((String) async throws -> Void)?
|
|
|
|
open override func reportRoom(reason: String) async throws {
|
|
if let error = reportRoomReasonThrowableError {
|
|
throw error
|
|
}
|
|
reportRoomReasonCallsCountLock.withLock { reportRoomReasonUnderlyingCallsCount += 1 }
|
|
reportRoomReasonReceivedReason = reason
|
|
reportRoomReasonReceivedInvocationsLock.withLock { reportRoomReasonUnderlyingReceivedInvocations.append(reason) }
|
|
try await reportRoomReasonClosure?(reason)
|
|
}
|
|
|
|
//MARK: - resetPowerLevels
|
|
|
|
open var resetPowerLevelsThrowableError: Error?
|
|
private let resetPowerLevelsCallsCountLock = NSLock()
|
|
private var resetPowerLevelsUnderlyingCallsCount = 0
|
|
open var resetPowerLevelsCallsCount: Int {
|
|
get { resetPowerLevelsCallsCountLock.withLock { resetPowerLevelsUnderlyingCallsCount } }
|
|
set { resetPowerLevelsCallsCountLock.withLock { resetPowerLevelsUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var resetPowerLevelsCalled: Bool {
|
|
return resetPowerLevelsCallsCount > 0
|
|
}
|
|
|
|
private let resetPowerLevelsReturnValueLock = NSLock()
|
|
open var resetPowerLevelsUnderlyingReturnValue: RoomPowerLevels!
|
|
open var resetPowerLevelsReturnValue: RoomPowerLevels! {
|
|
get { resetPowerLevelsReturnValueLock.withLock { resetPowerLevelsUnderlyingReturnValue } }
|
|
set { resetPowerLevelsReturnValueLock.withLock { resetPowerLevelsUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var resetPowerLevelsClosure: (() async throws -> RoomPowerLevels)?
|
|
|
|
open override func resetPowerLevels() async throws -> RoomPowerLevels {
|
|
if let error = resetPowerLevelsThrowableError {
|
|
throw error
|
|
}
|
|
resetPowerLevelsCallsCountLock.withLock { resetPowerLevelsUnderlyingCallsCount += 1 }
|
|
if let resetPowerLevelsClosure = resetPowerLevelsClosure {
|
|
return try await resetPowerLevelsClosure()
|
|
} else {
|
|
return resetPowerLevelsReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - roomEventsDebugString
|
|
|
|
open var roomEventsDebugStringThrowableError: Error?
|
|
private let roomEventsDebugStringCallsCountLock = NSLock()
|
|
private var roomEventsDebugStringUnderlyingCallsCount = 0
|
|
open var roomEventsDebugStringCallsCount: Int {
|
|
get { roomEventsDebugStringCallsCountLock.withLock { roomEventsDebugStringUnderlyingCallsCount } }
|
|
set { roomEventsDebugStringCallsCountLock.withLock { roomEventsDebugStringUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var roomEventsDebugStringCalled: Bool {
|
|
return roomEventsDebugStringCallsCount > 0
|
|
}
|
|
|
|
private let roomEventsDebugStringReturnValueLock = NSLock()
|
|
open var roomEventsDebugStringUnderlyingReturnValue: [String]!
|
|
open var roomEventsDebugStringReturnValue: [String]! {
|
|
get { roomEventsDebugStringReturnValueLock.withLock { roomEventsDebugStringUnderlyingReturnValue } }
|
|
set { roomEventsDebugStringReturnValueLock.withLock { roomEventsDebugStringUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var roomEventsDebugStringClosure: (() async throws -> [String])?
|
|
|
|
open override func roomEventsDebugString() async throws -> [String] {
|
|
if let error = roomEventsDebugStringThrowableError {
|
|
throw error
|
|
}
|
|
roomEventsDebugStringCallsCountLock.withLock { roomEventsDebugStringUnderlyingCallsCount += 1 }
|
|
if let roomEventsDebugStringClosure = roomEventsDebugStringClosure {
|
|
return try await roomEventsDebugStringClosure()
|
|
} else {
|
|
return roomEventsDebugStringReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - roomInfo
|
|
|
|
open var roomInfoThrowableError: Error?
|
|
private let roomInfoCallsCountLock = NSLock()
|
|
private var roomInfoUnderlyingCallsCount = 0
|
|
open var roomInfoCallsCount: Int {
|
|
get { roomInfoCallsCountLock.withLock { roomInfoUnderlyingCallsCount } }
|
|
set { roomInfoCallsCountLock.withLock { roomInfoUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var roomInfoCalled: Bool {
|
|
return roomInfoCallsCount > 0
|
|
}
|
|
|
|
private let roomInfoReturnValueLock = NSLock()
|
|
open var roomInfoUnderlyingReturnValue: RoomInfo!
|
|
open var roomInfoReturnValue: RoomInfo! {
|
|
get { roomInfoReturnValueLock.withLock { roomInfoUnderlyingReturnValue } }
|
|
set { roomInfoReturnValueLock.withLock { roomInfoUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var roomInfoClosure: (() async throws -> RoomInfo)?
|
|
|
|
open override func roomInfo() async throws -> RoomInfo {
|
|
if let error = roomInfoThrowableError {
|
|
throw error
|
|
}
|
|
roomInfoCallsCountLock.withLock { roomInfoUnderlyingCallsCount += 1 }
|
|
if let roomInfoClosure = roomInfoClosure {
|
|
return try await roomInfoClosure()
|
|
} else {
|
|
return roomInfoReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - saveComposerDraft
|
|
|
|
open var saveComposerDraftDraftThreadRootThrowableError: Error?
|
|
private let saveComposerDraftDraftThreadRootCallsCountLock = NSLock()
|
|
private var saveComposerDraftDraftThreadRootUnderlyingCallsCount = 0
|
|
open var saveComposerDraftDraftThreadRootCallsCount: Int {
|
|
get { saveComposerDraftDraftThreadRootCallsCountLock.withLock { saveComposerDraftDraftThreadRootUnderlyingCallsCount } }
|
|
set { saveComposerDraftDraftThreadRootCallsCountLock.withLock { saveComposerDraftDraftThreadRootUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var saveComposerDraftDraftThreadRootCalled: Bool {
|
|
return saveComposerDraftDraftThreadRootCallsCount > 0
|
|
}
|
|
private let saveComposerDraftDraftThreadRootReceivedArgumentsLock = NSLock()
|
|
private var saveComposerDraftDraftThreadRootUnderlyingReceivedArguments: (draft: ComposerDraft, threadRoot: String?)?
|
|
open var saveComposerDraftDraftThreadRootReceivedArguments: (draft: ComposerDraft, threadRoot: String?)? {
|
|
get { saveComposerDraftDraftThreadRootReceivedArgumentsLock.withLock { saveComposerDraftDraftThreadRootUnderlyingReceivedArguments } }
|
|
set { saveComposerDraftDraftThreadRootReceivedArgumentsLock.withLock { saveComposerDraftDraftThreadRootUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let saveComposerDraftDraftThreadRootReceivedInvocationsLock = NSLock()
|
|
private var saveComposerDraftDraftThreadRootUnderlyingReceivedInvocations: [(draft: ComposerDraft, threadRoot: String?)] = []
|
|
open var saveComposerDraftDraftThreadRootReceivedInvocations: [(draft: ComposerDraft, threadRoot: String?)] {
|
|
get { saveComposerDraftDraftThreadRootReceivedInvocationsLock.withLock { saveComposerDraftDraftThreadRootUnderlyingReceivedInvocations } }
|
|
set { saveComposerDraftDraftThreadRootReceivedInvocationsLock.withLock { saveComposerDraftDraftThreadRootUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var saveComposerDraftDraftThreadRootClosure: ((ComposerDraft, String?) async throws -> Void)?
|
|
|
|
open override func saveComposerDraft(draft: ComposerDraft, threadRoot: String?) async throws {
|
|
if let error = saveComposerDraftDraftThreadRootThrowableError {
|
|
throw error
|
|
}
|
|
saveComposerDraftDraftThreadRootCallsCountLock.withLock { saveComposerDraftDraftThreadRootUnderlyingCallsCount += 1 }
|
|
saveComposerDraftDraftThreadRootReceivedArguments = (draft: draft, threadRoot: threadRoot)
|
|
saveComposerDraftDraftThreadRootReceivedInvocationsLock.withLock { saveComposerDraftDraftThreadRootUnderlyingReceivedInvocations.append((draft: draft, threadRoot: threadRoot)) }
|
|
try await saveComposerDraftDraftThreadRootClosure?(draft, threadRoot)
|
|
}
|
|
|
|
//MARK: - sendLiveLocation
|
|
|
|
open var sendLiveLocationGeoUriThrowableError: Error?
|
|
private let sendLiveLocationGeoUriCallsCountLock = NSLock()
|
|
private var sendLiveLocationGeoUriUnderlyingCallsCount = 0
|
|
open var sendLiveLocationGeoUriCallsCount: Int {
|
|
get { sendLiveLocationGeoUriCallsCountLock.withLock { sendLiveLocationGeoUriUnderlyingCallsCount } }
|
|
set { sendLiveLocationGeoUriCallsCountLock.withLock { sendLiveLocationGeoUriUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var sendLiveLocationGeoUriCalled: Bool {
|
|
return sendLiveLocationGeoUriCallsCount > 0
|
|
}
|
|
private let sendLiveLocationGeoUriReceivedGeoUriLock = NSLock()
|
|
private var sendLiveLocationGeoUriUnderlyingReceivedGeoUri: String?
|
|
open var sendLiveLocationGeoUriReceivedGeoUri: String? {
|
|
get { sendLiveLocationGeoUriReceivedGeoUriLock.withLock { sendLiveLocationGeoUriUnderlyingReceivedGeoUri } }
|
|
set { sendLiveLocationGeoUriReceivedGeoUriLock.withLock { sendLiveLocationGeoUriUnderlyingReceivedGeoUri = newValue } }
|
|
}
|
|
private let sendLiveLocationGeoUriReceivedInvocationsLock = NSLock()
|
|
private var sendLiveLocationGeoUriUnderlyingReceivedInvocations: [String] = []
|
|
open var sendLiveLocationGeoUriReceivedInvocations: [String] {
|
|
get { sendLiveLocationGeoUriReceivedInvocationsLock.withLock { sendLiveLocationGeoUriUnderlyingReceivedInvocations } }
|
|
set { sendLiveLocationGeoUriReceivedInvocationsLock.withLock { sendLiveLocationGeoUriUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var sendLiveLocationGeoUriClosure: ((String) async throws -> Void)?
|
|
|
|
open override func sendLiveLocation(geoUri: String) async throws {
|
|
if let error = sendLiveLocationGeoUriThrowableError {
|
|
throw error
|
|
}
|
|
sendLiveLocationGeoUriCallsCountLock.withLock { sendLiveLocationGeoUriUnderlyingCallsCount += 1 }
|
|
sendLiveLocationGeoUriReceivedGeoUri = geoUri
|
|
sendLiveLocationGeoUriReceivedInvocationsLock.withLock { sendLiveLocationGeoUriUnderlyingReceivedInvocations.append(geoUri) }
|
|
try await sendLiveLocationGeoUriClosure?(geoUri)
|
|
}
|
|
|
|
//MARK: - sendRaw
|
|
|
|
open var sendRawEventTypeContentThrowableError: Error?
|
|
private let sendRawEventTypeContentCallsCountLock = NSLock()
|
|
private var sendRawEventTypeContentUnderlyingCallsCount = 0
|
|
open var sendRawEventTypeContentCallsCount: Int {
|
|
get { sendRawEventTypeContentCallsCountLock.withLock { sendRawEventTypeContentUnderlyingCallsCount } }
|
|
set { sendRawEventTypeContentCallsCountLock.withLock { sendRawEventTypeContentUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var sendRawEventTypeContentCalled: Bool {
|
|
return sendRawEventTypeContentCallsCount > 0
|
|
}
|
|
private let sendRawEventTypeContentReceivedArgumentsLock = NSLock()
|
|
private var sendRawEventTypeContentUnderlyingReceivedArguments: (eventType: String, content: String)?
|
|
open var sendRawEventTypeContentReceivedArguments: (eventType: String, content: String)? {
|
|
get { sendRawEventTypeContentReceivedArgumentsLock.withLock { sendRawEventTypeContentUnderlyingReceivedArguments } }
|
|
set { sendRawEventTypeContentReceivedArgumentsLock.withLock { sendRawEventTypeContentUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let sendRawEventTypeContentReceivedInvocationsLock = NSLock()
|
|
private var sendRawEventTypeContentUnderlyingReceivedInvocations: [(eventType: String, content: String)] = []
|
|
open var sendRawEventTypeContentReceivedInvocations: [(eventType: String, content: String)] {
|
|
get { sendRawEventTypeContentReceivedInvocationsLock.withLock { sendRawEventTypeContentUnderlyingReceivedInvocations } }
|
|
set { sendRawEventTypeContentReceivedInvocationsLock.withLock { sendRawEventTypeContentUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var sendRawEventTypeContentClosure: ((String, String) async throws -> Void)?
|
|
|
|
open override func sendRaw(eventType: String, content: String) async throws {
|
|
if let error = sendRawEventTypeContentThrowableError {
|
|
throw error
|
|
}
|
|
sendRawEventTypeContentCallsCountLock.withLock { sendRawEventTypeContentUnderlyingCallsCount += 1 }
|
|
sendRawEventTypeContentReceivedArguments = (eventType: eventType, content: content)
|
|
sendRawEventTypeContentReceivedInvocationsLock.withLock { sendRawEventTypeContentUnderlyingReceivedInvocations.append((eventType: eventType, content: content)) }
|
|
try await sendRawEventTypeContentClosure?(eventType, content)
|
|
}
|
|
|
|
//MARK: - sendStateEventRaw
|
|
|
|
open var sendStateEventRawEventTypeStateKeyContentThrowableError: Error?
|
|
private let sendStateEventRawEventTypeStateKeyContentCallsCountLock = NSLock()
|
|
private var sendStateEventRawEventTypeStateKeyContentUnderlyingCallsCount = 0
|
|
open var sendStateEventRawEventTypeStateKeyContentCallsCount: Int {
|
|
get { sendStateEventRawEventTypeStateKeyContentCallsCountLock.withLock { sendStateEventRawEventTypeStateKeyContentUnderlyingCallsCount } }
|
|
set { sendStateEventRawEventTypeStateKeyContentCallsCountLock.withLock { sendStateEventRawEventTypeStateKeyContentUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var sendStateEventRawEventTypeStateKeyContentCalled: Bool {
|
|
return sendStateEventRawEventTypeStateKeyContentCallsCount > 0
|
|
}
|
|
private let sendStateEventRawEventTypeStateKeyContentReceivedArgumentsLock = NSLock()
|
|
private var sendStateEventRawEventTypeStateKeyContentUnderlyingReceivedArguments: (eventType: String, stateKey: String, content: String)?
|
|
open var sendStateEventRawEventTypeStateKeyContentReceivedArguments: (eventType: String, stateKey: String, content: String)? {
|
|
get { sendStateEventRawEventTypeStateKeyContentReceivedArgumentsLock.withLock { sendStateEventRawEventTypeStateKeyContentUnderlyingReceivedArguments } }
|
|
set { sendStateEventRawEventTypeStateKeyContentReceivedArgumentsLock.withLock { sendStateEventRawEventTypeStateKeyContentUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let sendStateEventRawEventTypeStateKeyContentReceivedInvocationsLock = NSLock()
|
|
private var sendStateEventRawEventTypeStateKeyContentUnderlyingReceivedInvocations: [(eventType: String, stateKey: String, content: String)] = []
|
|
open var sendStateEventRawEventTypeStateKeyContentReceivedInvocations: [(eventType: String, stateKey: String, content: String)] {
|
|
get { sendStateEventRawEventTypeStateKeyContentReceivedInvocationsLock.withLock { sendStateEventRawEventTypeStateKeyContentUnderlyingReceivedInvocations } }
|
|
set { sendStateEventRawEventTypeStateKeyContentReceivedInvocationsLock.withLock { sendStateEventRawEventTypeStateKeyContentUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let sendStateEventRawEventTypeStateKeyContentReturnValueLock = NSLock()
|
|
open var sendStateEventRawEventTypeStateKeyContentUnderlyingReturnValue: String!
|
|
open var sendStateEventRawEventTypeStateKeyContentReturnValue: String! {
|
|
get { sendStateEventRawEventTypeStateKeyContentReturnValueLock.withLock { sendStateEventRawEventTypeStateKeyContentUnderlyingReturnValue } }
|
|
set { sendStateEventRawEventTypeStateKeyContentReturnValueLock.withLock { sendStateEventRawEventTypeStateKeyContentUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var sendStateEventRawEventTypeStateKeyContentClosure: ((String, String, String) async throws -> String)?
|
|
|
|
open override func sendStateEventRaw(eventType: String, stateKey: String, content: String) async throws -> String {
|
|
if let error = sendStateEventRawEventTypeStateKeyContentThrowableError {
|
|
throw error
|
|
}
|
|
sendStateEventRawEventTypeStateKeyContentCallsCountLock.withLock { sendStateEventRawEventTypeStateKeyContentUnderlyingCallsCount += 1 }
|
|
sendStateEventRawEventTypeStateKeyContentReceivedArguments = (eventType: eventType, stateKey: stateKey, content: content)
|
|
sendStateEventRawEventTypeStateKeyContentReceivedInvocationsLock.withLock { sendStateEventRawEventTypeStateKeyContentUnderlyingReceivedInvocations.append((eventType: eventType, stateKey: stateKey, content: content)) }
|
|
if let sendStateEventRawEventTypeStateKeyContentClosure = sendStateEventRawEventTypeStateKeyContentClosure {
|
|
return try await sendStateEventRawEventTypeStateKeyContentClosure(eventType, stateKey, content)
|
|
} else {
|
|
return sendStateEventRawEventTypeStateKeyContentReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - setIsFavourite
|
|
|
|
open var setIsFavouriteIsFavouriteTagOrderThrowableError: Error?
|
|
private let setIsFavouriteIsFavouriteTagOrderCallsCountLock = NSLock()
|
|
private var setIsFavouriteIsFavouriteTagOrderUnderlyingCallsCount = 0
|
|
open var setIsFavouriteIsFavouriteTagOrderCallsCount: Int {
|
|
get { setIsFavouriteIsFavouriteTagOrderCallsCountLock.withLock { setIsFavouriteIsFavouriteTagOrderUnderlyingCallsCount } }
|
|
set { setIsFavouriteIsFavouriteTagOrderCallsCountLock.withLock { setIsFavouriteIsFavouriteTagOrderUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var setIsFavouriteIsFavouriteTagOrderCalled: Bool {
|
|
return setIsFavouriteIsFavouriteTagOrderCallsCount > 0
|
|
}
|
|
private let setIsFavouriteIsFavouriteTagOrderReceivedArgumentsLock = NSLock()
|
|
private var setIsFavouriteIsFavouriteTagOrderUnderlyingReceivedArguments: (isFavourite: Bool, tagOrder: Double?)?
|
|
open var setIsFavouriteIsFavouriteTagOrderReceivedArguments: (isFavourite: Bool, tagOrder: Double?)? {
|
|
get { setIsFavouriteIsFavouriteTagOrderReceivedArgumentsLock.withLock { setIsFavouriteIsFavouriteTagOrderUnderlyingReceivedArguments } }
|
|
set { setIsFavouriteIsFavouriteTagOrderReceivedArgumentsLock.withLock { setIsFavouriteIsFavouriteTagOrderUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let setIsFavouriteIsFavouriteTagOrderReceivedInvocationsLock = NSLock()
|
|
private var setIsFavouriteIsFavouriteTagOrderUnderlyingReceivedInvocations: [(isFavourite: Bool, tagOrder: Double?)] = []
|
|
open var setIsFavouriteIsFavouriteTagOrderReceivedInvocations: [(isFavourite: Bool, tagOrder: Double?)] {
|
|
get { setIsFavouriteIsFavouriteTagOrderReceivedInvocationsLock.withLock { setIsFavouriteIsFavouriteTagOrderUnderlyingReceivedInvocations } }
|
|
set { setIsFavouriteIsFavouriteTagOrderReceivedInvocationsLock.withLock { setIsFavouriteIsFavouriteTagOrderUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var setIsFavouriteIsFavouriteTagOrderClosure: ((Bool, Double?) async throws -> Void)?
|
|
|
|
open override func setIsFavourite(isFavourite: Bool, tagOrder: Double?) async throws {
|
|
if let error = setIsFavouriteIsFavouriteTagOrderThrowableError {
|
|
throw error
|
|
}
|
|
setIsFavouriteIsFavouriteTagOrderCallsCountLock.withLock { setIsFavouriteIsFavouriteTagOrderUnderlyingCallsCount += 1 }
|
|
setIsFavouriteIsFavouriteTagOrderReceivedArguments = (isFavourite: isFavourite, tagOrder: tagOrder)
|
|
setIsFavouriteIsFavouriteTagOrderReceivedInvocationsLock.withLock { setIsFavouriteIsFavouriteTagOrderUnderlyingReceivedInvocations.append((isFavourite: isFavourite, tagOrder: tagOrder)) }
|
|
try await setIsFavouriteIsFavouriteTagOrderClosure?(isFavourite, tagOrder)
|
|
}
|
|
|
|
//MARK: - setIsLowPriority
|
|
|
|
open var setIsLowPriorityIsLowPriorityTagOrderThrowableError: Error?
|
|
private let setIsLowPriorityIsLowPriorityTagOrderCallsCountLock = NSLock()
|
|
private var setIsLowPriorityIsLowPriorityTagOrderUnderlyingCallsCount = 0
|
|
open var setIsLowPriorityIsLowPriorityTagOrderCallsCount: Int {
|
|
get { setIsLowPriorityIsLowPriorityTagOrderCallsCountLock.withLock { setIsLowPriorityIsLowPriorityTagOrderUnderlyingCallsCount } }
|
|
set { setIsLowPriorityIsLowPriorityTagOrderCallsCountLock.withLock { setIsLowPriorityIsLowPriorityTagOrderUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var setIsLowPriorityIsLowPriorityTagOrderCalled: Bool {
|
|
return setIsLowPriorityIsLowPriorityTagOrderCallsCount > 0
|
|
}
|
|
private let setIsLowPriorityIsLowPriorityTagOrderReceivedArgumentsLock = NSLock()
|
|
private var setIsLowPriorityIsLowPriorityTagOrderUnderlyingReceivedArguments: (isLowPriority: Bool, tagOrder: Double?)?
|
|
open var setIsLowPriorityIsLowPriorityTagOrderReceivedArguments: (isLowPriority: Bool, tagOrder: Double?)? {
|
|
get { setIsLowPriorityIsLowPriorityTagOrderReceivedArgumentsLock.withLock { setIsLowPriorityIsLowPriorityTagOrderUnderlyingReceivedArguments } }
|
|
set { setIsLowPriorityIsLowPriorityTagOrderReceivedArgumentsLock.withLock { setIsLowPriorityIsLowPriorityTagOrderUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let setIsLowPriorityIsLowPriorityTagOrderReceivedInvocationsLock = NSLock()
|
|
private var setIsLowPriorityIsLowPriorityTagOrderUnderlyingReceivedInvocations: [(isLowPriority: Bool, tagOrder: Double?)] = []
|
|
open var setIsLowPriorityIsLowPriorityTagOrderReceivedInvocations: [(isLowPriority: Bool, tagOrder: Double?)] {
|
|
get { setIsLowPriorityIsLowPriorityTagOrderReceivedInvocationsLock.withLock { setIsLowPriorityIsLowPriorityTagOrderUnderlyingReceivedInvocations } }
|
|
set { setIsLowPriorityIsLowPriorityTagOrderReceivedInvocationsLock.withLock { setIsLowPriorityIsLowPriorityTagOrderUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var setIsLowPriorityIsLowPriorityTagOrderClosure: ((Bool, Double?) async throws -> Void)?
|
|
|
|
open override func setIsLowPriority(isLowPriority: Bool, tagOrder: Double?) async throws {
|
|
if let error = setIsLowPriorityIsLowPriorityTagOrderThrowableError {
|
|
throw error
|
|
}
|
|
setIsLowPriorityIsLowPriorityTagOrderCallsCountLock.withLock { setIsLowPriorityIsLowPriorityTagOrderUnderlyingCallsCount += 1 }
|
|
setIsLowPriorityIsLowPriorityTagOrderReceivedArguments = (isLowPriority: isLowPriority, tagOrder: tagOrder)
|
|
setIsLowPriorityIsLowPriorityTagOrderReceivedInvocationsLock.withLock { setIsLowPriorityIsLowPriorityTagOrderUnderlyingReceivedInvocations.append((isLowPriority: isLowPriority, tagOrder: tagOrder)) }
|
|
try await setIsLowPriorityIsLowPriorityTagOrderClosure?(isLowPriority, tagOrder)
|
|
}
|
|
|
|
//MARK: - setName
|
|
|
|
open var setNameNameThrowableError: Error?
|
|
private let setNameNameCallsCountLock = NSLock()
|
|
private var setNameNameUnderlyingCallsCount = 0
|
|
open var setNameNameCallsCount: Int {
|
|
get { setNameNameCallsCountLock.withLock { setNameNameUnderlyingCallsCount } }
|
|
set { setNameNameCallsCountLock.withLock { setNameNameUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var setNameNameCalled: Bool {
|
|
return setNameNameCallsCount > 0
|
|
}
|
|
private let setNameNameReceivedNameLock = NSLock()
|
|
private var setNameNameUnderlyingReceivedName: String?
|
|
open var setNameNameReceivedName: String? {
|
|
get { setNameNameReceivedNameLock.withLock { setNameNameUnderlyingReceivedName } }
|
|
set { setNameNameReceivedNameLock.withLock { setNameNameUnderlyingReceivedName = newValue } }
|
|
}
|
|
private let setNameNameReceivedInvocationsLock = NSLock()
|
|
private var setNameNameUnderlyingReceivedInvocations: [String] = []
|
|
open var setNameNameReceivedInvocations: [String] {
|
|
get { setNameNameReceivedInvocationsLock.withLock { setNameNameUnderlyingReceivedInvocations } }
|
|
set { setNameNameReceivedInvocationsLock.withLock { setNameNameUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var setNameNameClosure: ((String) async throws -> Void)?
|
|
|
|
open override func setName(name: String) async throws {
|
|
if let error = setNameNameThrowableError {
|
|
throw error
|
|
}
|
|
setNameNameCallsCountLock.withLock { setNameNameUnderlyingCallsCount += 1 }
|
|
setNameNameReceivedName = name
|
|
setNameNameReceivedInvocationsLock.withLock { setNameNameUnderlyingReceivedInvocations.append(name) }
|
|
try await setNameNameClosure?(name)
|
|
}
|
|
|
|
//MARK: - setOwnMemberDisplayName
|
|
|
|
open var setOwnMemberDisplayNameDisplayNameThrowableError: Error?
|
|
private let setOwnMemberDisplayNameDisplayNameCallsCountLock = NSLock()
|
|
private var setOwnMemberDisplayNameDisplayNameUnderlyingCallsCount = 0
|
|
open var setOwnMemberDisplayNameDisplayNameCallsCount: Int {
|
|
get { setOwnMemberDisplayNameDisplayNameCallsCountLock.withLock { setOwnMemberDisplayNameDisplayNameUnderlyingCallsCount } }
|
|
set { setOwnMemberDisplayNameDisplayNameCallsCountLock.withLock { setOwnMemberDisplayNameDisplayNameUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var setOwnMemberDisplayNameDisplayNameCalled: Bool {
|
|
return setOwnMemberDisplayNameDisplayNameCallsCount > 0
|
|
}
|
|
private let setOwnMemberDisplayNameDisplayNameReceivedDisplayNameLock = NSLock()
|
|
private var setOwnMemberDisplayNameDisplayNameUnderlyingReceivedDisplayName: String?
|
|
open var setOwnMemberDisplayNameDisplayNameReceivedDisplayName: String? {
|
|
get { setOwnMemberDisplayNameDisplayNameReceivedDisplayNameLock.withLock { setOwnMemberDisplayNameDisplayNameUnderlyingReceivedDisplayName } }
|
|
set { setOwnMemberDisplayNameDisplayNameReceivedDisplayNameLock.withLock { setOwnMemberDisplayNameDisplayNameUnderlyingReceivedDisplayName = newValue } }
|
|
}
|
|
private let setOwnMemberDisplayNameDisplayNameReceivedInvocationsLock = NSLock()
|
|
private var setOwnMemberDisplayNameDisplayNameUnderlyingReceivedInvocations: [String?] = []
|
|
open var setOwnMemberDisplayNameDisplayNameReceivedInvocations: [String?] {
|
|
get { setOwnMemberDisplayNameDisplayNameReceivedInvocationsLock.withLock { setOwnMemberDisplayNameDisplayNameUnderlyingReceivedInvocations } }
|
|
set { setOwnMemberDisplayNameDisplayNameReceivedInvocationsLock.withLock { setOwnMemberDisplayNameDisplayNameUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var setOwnMemberDisplayNameDisplayNameClosure: ((String?) async throws -> Void)?
|
|
|
|
open override func setOwnMemberDisplayName(displayName: String?) async throws {
|
|
if let error = setOwnMemberDisplayNameDisplayNameThrowableError {
|
|
throw error
|
|
}
|
|
setOwnMemberDisplayNameDisplayNameCallsCountLock.withLock { setOwnMemberDisplayNameDisplayNameUnderlyingCallsCount += 1 }
|
|
setOwnMemberDisplayNameDisplayNameReceivedDisplayName = displayName
|
|
setOwnMemberDisplayNameDisplayNameReceivedInvocationsLock.withLock { setOwnMemberDisplayNameDisplayNameUnderlyingReceivedInvocations.append(displayName) }
|
|
try await setOwnMemberDisplayNameDisplayNameClosure?(displayName)
|
|
}
|
|
|
|
//MARK: - setThreadSubscription
|
|
|
|
open var setThreadSubscriptionThreadRootEventIdSubscribedThrowableError: Error?
|
|
private let setThreadSubscriptionThreadRootEventIdSubscribedCallsCountLock = NSLock()
|
|
private var setThreadSubscriptionThreadRootEventIdSubscribedUnderlyingCallsCount = 0
|
|
open var setThreadSubscriptionThreadRootEventIdSubscribedCallsCount: Int {
|
|
get { setThreadSubscriptionThreadRootEventIdSubscribedCallsCountLock.withLock { setThreadSubscriptionThreadRootEventIdSubscribedUnderlyingCallsCount } }
|
|
set { setThreadSubscriptionThreadRootEventIdSubscribedCallsCountLock.withLock { setThreadSubscriptionThreadRootEventIdSubscribedUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var setThreadSubscriptionThreadRootEventIdSubscribedCalled: Bool {
|
|
return setThreadSubscriptionThreadRootEventIdSubscribedCallsCount > 0
|
|
}
|
|
private let setThreadSubscriptionThreadRootEventIdSubscribedReceivedArgumentsLock = NSLock()
|
|
private var setThreadSubscriptionThreadRootEventIdSubscribedUnderlyingReceivedArguments: (threadRootEventId: String, subscribed: Bool)?
|
|
open var setThreadSubscriptionThreadRootEventIdSubscribedReceivedArguments: (threadRootEventId: String, subscribed: Bool)? {
|
|
get { setThreadSubscriptionThreadRootEventIdSubscribedReceivedArgumentsLock.withLock { setThreadSubscriptionThreadRootEventIdSubscribedUnderlyingReceivedArguments } }
|
|
set { setThreadSubscriptionThreadRootEventIdSubscribedReceivedArgumentsLock.withLock { setThreadSubscriptionThreadRootEventIdSubscribedUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let setThreadSubscriptionThreadRootEventIdSubscribedReceivedInvocationsLock = NSLock()
|
|
private var setThreadSubscriptionThreadRootEventIdSubscribedUnderlyingReceivedInvocations: [(threadRootEventId: String, subscribed: Bool)] = []
|
|
open var setThreadSubscriptionThreadRootEventIdSubscribedReceivedInvocations: [(threadRootEventId: String, subscribed: Bool)] {
|
|
get { setThreadSubscriptionThreadRootEventIdSubscribedReceivedInvocationsLock.withLock { setThreadSubscriptionThreadRootEventIdSubscribedUnderlyingReceivedInvocations } }
|
|
set { setThreadSubscriptionThreadRootEventIdSubscribedReceivedInvocationsLock.withLock { setThreadSubscriptionThreadRootEventIdSubscribedUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var setThreadSubscriptionThreadRootEventIdSubscribedClosure: ((String, Bool) async throws -> Void)?
|
|
|
|
open override func setThreadSubscription(threadRootEventId: String, subscribed: Bool) async throws {
|
|
if let error = setThreadSubscriptionThreadRootEventIdSubscribedThrowableError {
|
|
throw error
|
|
}
|
|
setThreadSubscriptionThreadRootEventIdSubscribedCallsCountLock.withLock { setThreadSubscriptionThreadRootEventIdSubscribedUnderlyingCallsCount += 1 }
|
|
setThreadSubscriptionThreadRootEventIdSubscribedReceivedArguments = (threadRootEventId: threadRootEventId, subscribed: subscribed)
|
|
setThreadSubscriptionThreadRootEventIdSubscribedReceivedInvocationsLock.withLock { setThreadSubscriptionThreadRootEventIdSubscribedUnderlyingReceivedInvocations.append((threadRootEventId: threadRootEventId, subscribed: subscribed)) }
|
|
try await setThreadSubscriptionThreadRootEventIdSubscribedClosure?(threadRootEventId, subscribed)
|
|
}
|
|
|
|
//MARK: - setTopic
|
|
|
|
open var setTopicTopicThrowableError: Error?
|
|
private let setTopicTopicCallsCountLock = NSLock()
|
|
private var setTopicTopicUnderlyingCallsCount = 0
|
|
open var setTopicTopicCallsCount: Int {
|
|
get { setTopicTopicCallsCountLock.withLock { setTopicTopicUnderlyingCallsCount } }
|
|
set { setTopicTopicCallsCountLock.withLock { setTopicTopicUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var setTopicTopicCalled: Bool {
|
|
return setTopicTopicCallsCount > 0
|
|
}
|
|
private let setTopicTopicReceivedTopicLock = NSLock()
|
|
private var setTopicTopicUnderlyingReceivedTopic: String?
|
|
open var setTopicTopicReceivedTopic: String? {
|
|
get { setTopicTopicReceivedTopicLock.withLock { setTopicTopicUnderlyingReceivedTopic } }
|
|
set { setTopicTopicReceivedTopicLock.withLock { setTopicTopicUnderlyingReceivedTopic = newValue } }
|
|
}
|
|
private let setTopicTopicReceivedInvocationsLock = NSLock()
|
|
private var setTopicTopicUnderlyingReceivedInvocations: [String] = []
|
|
open var setTopicTopicReceivedInvocations: [String] {
|
|
get { setTopicTopicReceivedInvocationsLock.withLock { setTopicTopicUnderlyingReceivedInvocations } }
|
|
set { setTopicTopicReceivedInvocationsLock.withLock { setTopicTopicUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var setTopicTopicClosure: ((String) async throws -> Void)?
|
|
|
|
open override func setTopic(topic: String) async throws {
|
|
if let error = setTopicTopicThrowableError {
|
|
throw error
|
|
}
|
|
setTopicTopicCallsCountLock.withLock { setTopicTopicUnderlyingCallsCount += 1 }
|
|
setTopicTopicReceivedTopic = topic
|
|
setTopicTopicReceivedInvocationsLock.withLock { setTopicTopicUnderlyingReceivedInvocations.append(topic) }
|
|
try await setTopicTopicClosure?(topic)
|
|
}
|
|
|
|
//MARK: - setUnreadFlag
|
|
|
|
open var setUnreadFlagNewValueThrowableError: Error?
|
|
private let setUnreadFlagNewValueCallsCountLock = NSLock()
|
|
private var setUnreadFlagNewValueUnderlyingCallsCount = 0
|
|
open var setUnreadFlagNewValueCallsCount: Int {
|
|
get { setUnreadFlagNewValueCallsCountLock.withLock { setUnreadFlagNewValueUnderlyingCallsCount } }
|
|
set { setUnreadFlagNewValueCallsCountLock.withLock { setUnreadFlagNewValueUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var setUnreadFlagNewValueCalled: Bool {
|
|
return setUnreadFlagNewValueCallsCount > 0
|
|
}
|
|
private let setUnreadFlagNewValueReceivedNewValueLock = NSLock()
|
|
private var setUnreadFlagNewValueUnderlyingReceivedNewValue: Bool?
|
|
open var setUnreadFlagNewValueReceivedNewValue: Bool? {
|
|
get { setUnreadFlagNewValueReceivedNewValueLock.withLock { setUnreadFlagNewValueUnderlyingReceivedNewValue } }
|
|
set { setUnreadFlagNewValueReceivedNewValueLock.withLock { setUnreadFlagNewValueUnderlyingReceivedNewValue = newValue } }
|
|
}
|
|
private let setUnreadFlagNewValueReceivedInvocationsLock = NSLock()
|
|
private var setUnreadFlagNewValueUnderlyingReceivedInvocations: [Bool] = []
|
|
open var setUnreadFlagNewValueReceivedInvocations: [Bool] {
|
|
get { setUnreadFlagNewValueReceivedInvocationsLock.withLock { setUnreadFlagNewValueUnderlyingReceivedInvocations } }
|
|
set { setUnreadFlagNewValueReceivedInvocationsLock.withLock { setUnreadFlagNewValueUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var setUnreadFlagNewValueClosure: ((Bool) async throws -> Void)?
|
|
|
|
open override func setUnreadFlag(newValue: Bool) async throws {
|
|
if let error = setUnreadFlagNewValueThrowableError {
|
|
throw error
|
|
}
|
|
setUnreadFlagNewValueCallsCountLock.withLock { setUnreadFlagNewValueUnderlyingCallsCount += 1 }
|
|
setUnreadFlagNewValueReceivedNewValue = newValue
|
|
setUnreadFlagNewValueReceivedInvocationsLock.withLock { setUnreadFlagNewValueUnderlyingReceivedInvocations.append(newValue) }
|
|
try await setUnreadFlagNewValueClosure?(newValue)
|
|
}
|
|
|
|
//MARK: - startLiveLocationShare
|
|
|
|
open var startLiveLocationShareDurationMillisThrowableError: Error?
|
|
private let startLiveLocationShareDurationMillisCallsCountLock = NSLock()
|
|
private var startLiveLocationShareDurationMillisUnderlyingCallsCount = 0
|
|
open var startLiveLocationShareDurationMillisCallsCount: Int {
|
|
get { startLiveLocationShareDurationMillisCallsCountLock.withLock { startLiveLocationShareDurationMillisUnderlyingCallsCount } }
|
|
set { startLiveLocationShareDurationMillisCallsCountLock.withLock { startLiveLocationShareDurationMillisUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var startLiveLocationShareDurationMillisCalled: Bool {
|
|
return startLiveLocationShareDurationMillisCallsCount > 0
|
|
}
|
|
private let startLiveLocationShareDurationMillisReceivedDurationMillisLock = NSLock()
|
|
private var startLiveLocationShareDurationMillisUnderlyingReceivedDurationMillis: UInt64?
|
|
open var startLiveLocationShareDurationMillisReceivedDurationMillis: UInt64? {
|
|
get { startLiveLocationShareDurationMillisReceivedDurationMillisLock.withLock { startLiveLocationShareDurationMillisUnderlyingReceivedDurationMillis } }
|
|
set { startLiveLocationShareDurationMillisReceivedDurationMillisLock.withLock { startLiveLocationShareDurationMillisUnderlyingReceivedDurationMillis = newValue } }
|
|
}
|
|
private let startLiveLocationShareDurationMillisReceivedInvocationsLock = NSLock()
|
|
private var startLiveLocationShareDurationMillisUnderlyingReceivedInvocations: [UInt64] = []
|
|
open var startLiveLocationShareDurationMillisReceivedInvocations: [UInt64] {
|
|
get { startLiveLocationShareDurationMillisReceivedInvocationsLock.withLock { startLiveLocationShareDurationMillisUnderlyingReceivedInvocations } }
|
|
set { startLiveLocationShareDurationMillisReceivedInvocationsLock.withLock { startLiveLocationShareDurationMillisUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let startLiveLocationShareDurationMillisReturnValueLock = NSLock()
|
|
open var startLiveLocationShareDurationMillisUnderlyingReturnValue: String!
|
|
open var startLiveLocationShareDurationMillisReturnValue: String! {
|
|
get { startLiveLocationShareDurationMillisReturnValueLock.withLock { startLiveLocationShareDurationMillisUnderlyingReturnValue } }
|
|
set { startLiveLocationShareDurationMillisReturnValueLock.withLock { startLiveLocationShareDurationMillisUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var startLiveLocationShareDurationMillisClosure: ((UInt64) async throws -> String)?
|
|
|
|
open override func startLiveLocationShare(durationMillis: UInt64) async throws -> String {
|
|
if let error = startLiveLocationShareDurationMillisThrowableError {
|
|
throw error
|
|
}
|
|
startLiveLocationShareDurationMillisCallsCountLock.withLock { startLiveLocationShareDurationMillisUnderlyingCallsCount += 1 }
|
|
startLiveLocationShareDurationMillisReceivedDurationMillis = durationMillis
|
|
startLiveLocationShareDurationMillisReceivedInvocationsLock.withLock { startLiveLocationShareDurationMillisUnderlyingReceivedInvocations.append(durationMillis) }
|
|
if let startLiveLocationShareDurationMillisClosure = startLiveLocationShareDurationMillisClosure {
|
|
return try await startLiveLocationShareDurationMillisClosure(durationMillis)
|
|
} else {
|
|
return startLiveLocationShareDurationMillisReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - stopLiveLocationShare
|
|
|
|
open var stopLiveLocationShareThrowableError: Error?
|
|
private let stopLiveLocationShareCallsCountLock = NSLock()
|
|
private var stopLiveLocationShareUnderlyingCallsCount = 0
|
|
open var stopLiveLocationShareCallsCount: Int {
|
|
get { stopLiveLocationShareCallsCountLock.withLock { stopLiveLocationShareUnderlyingCallsCount } }
|
|
set { stopLiveLocationShareCallsCountLock.withLock { stopLiveLocationShareUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var stopLiveLocationShareCalled: Bool {
|
|
return stopLiveLocationShareCallsCount > 0
|
|
}
|
|
open var stopLiveLocationShareClosure: (() async throws -> Void)?
|
|
|
|
open override func stopLiveLocationShare() async throws {
|
|
if let error = stopLiveLocationShareThrowableError {
|
|
throw error
|
|
}
|
|
stopLiveLocationShareCallsCountLock.withLock { stopLiveLocationShareUnderlyingCallsCount += 1 }
|
|
try await stopLiveLocationShareClosure?()
|
|
}
|
|
|
|
//MARK: - subscribeToCallDeclineEvents
|
|
|
|
open var subscribeToCallDeclineEventsRtcNotificationEventIdListenerThrowableError: Error?
|
|
private let subscribeToCallDeclineEventsRtcNotificationEventIdListenerCallsCountLock = NSLock()
|
|
private var subscribeToCallDeclineEventsRtcNotificationEventIdListenerUnderlyingCallsCount = 0
|
|
open var subscribeToCallDeclineEventsRtcNotificationEventIdListenerCallsCount: Int {
|
|
get { subscribeToCallDeclineEventsRtcNotificationEventIdListenerCallsCountLock.withLock { subscribeToCallDeclineEventsRtcNotificationEventIdListenerUnderlyingCallsCount } }
|
|
set { subscribeToCallDeclineEventsRtcNotificationEventIdListenerCallsCountLock.withLock { subscribeToCallDeclineEventsRtcNotificationEventIdListenerUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var subscribeToCallDeclineEventsRtcNotificationEventIdListenerCalled: Bool {
|
|
return subscribeToCallDeclineEventsRtcNotificationEventIdListenerCallsCount > 0
|
|
}
|
|
private let subscribeToCallDeclineEventsRtcNotificationEventIdListenerReceivedArgumentsLock = NSLock()
|
|
private var subscribeToCallDeclineEventsRtcNotificationEventIdListenerUnderlyingReceivedArguments: (rtcNotificationEventId: String, listener: CallDeclineListener)?
|
|
open var subscribeToCallDeclineEventsRtcNotificationEventIdListenerReceivedArguments: (rtcNotificationEventId: String, listener: CallDeclineListener)? {
|
|
get { subscribeToCallDeclineEventsRtcNotificationEventIdListenerReceivedArgumentsLock.withLock { subscribeToCallDeclineEventsRtcNotificationEventIdListenerUnderlyingReceivedArguments } }
|
|
set { subscribeToCallDeclineEventsRtcNotificationEventIdListenerReceivedArgumentsLock.withLock { subscribeToCallDeclineEventsRtcNotificationEventIdListenerUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let subscribeToCallDeclineEventsRtcNotificationEventIdListenerReceivedInvocationsLock = NSLock()
|
|
private var subscribeToCallDeclineEventsRtcNotificationEventIdListenerUnderlyingReceivedInvocations: [(rtcNotificationEventId: String, listener: CallDeclineListener)] = []
|
|
open var subscribeToCallDeclineEventsRtcNotificationEventIdListenerReceivedInvocations: [(rtcNotificationEventId: String, listener: CallDeclineListener)] {
|
|
get { subscribeToCallDeclineEventsRtcNotificationEventIdListenerReceivedInvocationsLock.withLock { subscribeToCallDeclineEventsRtcNotificationEventIdListenerUnderlyingReceivedInvocations } }
|
|
set { subscribeToCallDeclineEventsRtcNotificationEventIdListenerReceivedInvocationsLock.withLock { subscribeToCallDeclineEventsRtcNotificationEventIdListenerUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let subscribeToCallDeclineEventsRtcNotificationEventIdListenerReturnValueLock = NSLock()
|
|
open var subscribeToCallDeclineEventsRtcNotificationEventIdListenerUnderlyingReturnValue: TaskHandle!
|
|
open var subscribeToCallDeclineEventsRtcNotificationEventIdListenerReturnValue: TaskHandle! {
|
|
get { subscribeToCallDeclineEventsRtcNotificationEventIdListenerReturnValueLock.withLock { subscribeToCallDeclineEventsRtcNotificationEventIdListenerUnderlyingReturnValue } }
|
|
set { subscribeToCallDeclineEventsRtcNotificationEventIdListenerReturnValueLock.withLock { subscribeToCallDeclineEventsRtcNotificationEventIdListenerUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var subscribeToCallDeclineEventsRtcNotificationEventIdListenerClosure: ((String, CallDeclineListener) throws -> TaskHandle)?
|
|
|
|
open override func subscribeToCallDeclineEvents(rtcNotificationEventId: String, listener: CallDeclineListener) throws -> TaskHandle {
|
|
if let error = subscribeToCallDeclineEventsRtcNotificationEventIdListenerThrowableError {
|
|
throw error
|
|
}
|
|
subscribeToCallDeclineEventsRtcNotificationEventIdListenerCallsCountLock.withLock { subscribeToCallDeclineEventsRtcNotificationEventIdListenerUnderlyingCallsCount += 1 }
|
|
subscribeToCallDeclineEventsRtcNotificationEventIdListenerReceivedArguments = (rtcNotificationEventId: rtcNotificationEventId, listener: listener)
|
|
subscribeToCallDeclineEventsRtcNotificationEventIdListenerReceivedInvocationsLock.withLock { subscribeToCallDeclineEventsRtcNotificationEventIdListenerUnderlyingReceivedInvocations.append((rtcNotificationEventId: rtcNotificationEventId, listener: listener)) }
|
|
if let subscribeToCallDeclineEventsRtcNotificationEventIdListenerClosure = subscribeToCallDeclineEventsRtcNotificationEventIdListenerClosure {
|
|
return try subscribeToCallDeclineEventsRtcNotificationEventIdListenerClosure(rtcNotificationEventId, listener)
|
|
} else {
|
|
return subscribeToCallDeclineEventsRtcNotificationEventIdListenerReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - subscribeToIdentityStatusChanges
|
|
|
|
open var subscribeToIdentityStatusChangesListenerThrowableError: Error?
|
|
private let subscribeToIdentityStatusChangesListenerCallsCountLock = NSLock()
|
|
private var subscribeToIdentityStatusChangesListenerUnderlyingCallsCount = 0
|
|
open var subscribeToIdentityStatusChangesListenerCallsCount: Int {
|
|
get { subscribeToIdentityStatusChangesListenerCallsCountLock.withLock { subscribeToIdentityStatusChangesListenerUnderlyingCallsCount } }
|
|
set { subscribeToIdentityStatusChangesListenerCallsCountLock.withLock { subscribeToIdentityStatusChangesListenerUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var subscribeToIdentityStatusChangesListenerCalled: Bool {
|
|
return subscribeToIdentityStatusChangesListenerCallsCount > 0
|
|
}
|
|
private let subscribeToIdentityStatusChangesListenerReceivedListenerLock = NSLock()
|
|
private var subscribeToIdentityStatusChangesListenerUnderlyingReceivedListener: IdentityStatusChangeListener?
|
|
open var subscribeToIdentityStatusChangesListenerReceivedListener: IdentityStatusChangeListener? {
|
|
get { subscribeToIdentityStatusChangesListenerReceivedListenerLock.withLock { subscribeToIdentityStatusChangesListenerUnderlyingReceivedListener } }
|
|
set { subscribeToIdentityStatusChangesListenerReceivedListenerLock.withLock { subscribeToIdentityStatusChangesListenerUnderlyingReceivedListener = newValue } }
|
|
}
|
|
private let subscribeToIdentityStatusChangesListenerReceivedInvocationsLock = NSLock()
|
|
private var subscribeToIdentityStatusChangesListenerUnderlyingReceivedInvocations: [IdentityStatusChangeListener] = []
|
|
open var subscribeToIdentityStatusChangesListenerReceivedInvocations: [IdentityStatusChangeListener] {
|
|
get { subscribeToIdentityStatusChangesListenerReceivedInvocationsLock.withLock { subscribeToIdentityStatusChangesListenerUnderlyingReceivedInvocations } }
|
|
set { subscribeToIdentityStatusChangesListenerReceivedInvocationsLock.withLock { subscribeToIdentityStatusChangesListenerUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let subscribeToIdentityStatusChangesListenerReturnValueLock = NSLock()
|
|
open var subscribeToIdentityStatusChangesListenerUnderlyingReturnValue: TaskHandle!
|
|
open var subscribeToIdentityStatusChangesListenerReturnValue: TaskHandle! {
|
|
get { subscribeToIdentityStatusChangesListenerReturnValueLock.withLock { subscribeToIdentityStatusChangesListenerUnderlyingReturnValue } }
|
|
set { subscribeToIdentityStatusChangesListenerReturnValueLock.withLock { subscribeToIdentityStatusChangesListenerUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var subscribeToIdentityStatusChangesListenerClosure: ((IdentityStatusChangeListener) async throws -> TaskHandle)?
|
|
|
|
open override func subscribeToIdentityStatusChanges(listener: IdentityStatusChangeListener) async throws -> TaskHandle {
|
|
if let error = subscribeToIdentityStatusChangesListenerThrowableError {
|
|
throw error
|
|
}
|
|
subscribeToIdentityStatusChangesListenerCallsCountLock.withLock { subscribeToIdentityStatusChangesListenerUnderlyingCallsCount += 1 }
|
|
subscribeToIdentityStatusChangesListenerReceivedListener = listener
|
|
subscribeToIdentityStatusChangesListenerReceivedInvocationsLock.withLock { subscribeToIdentityStatusChangesListenerUnderlyingReceivedInvocations.append(listener) }
|
|
if let subscribeToIdentityStatusChangesListenerClosure = subscribeToIdentityStatusChangesListenerClosure {
|
|
return try await subscribeToIdentityStatusChangesListenerClosure(listener)
|
|
} else {
|
|
return subscribeToIdentityStatusChangesListenerReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - subscribeToKnockRequests
|
|
|
|
open var subscribeToKnockRequestsListenerThrowableError: Error?
|
|
private let subscribeToKnockRequestsListenerCallsCountLock = NSLock()
|
|
private var subscribeToKnockRequestsListenerUnderlyingCallsCount = 0
|
|
open var subscribeToKnockRequestsListenerCallsCount: Int {
|
|
get { subscribeToKnockRequestsListenerCallsCountLock.withLock { subscribeToKnockRequestsListenerUnderlyingCallsCount } }
|
|
set { subscribeToKnockRequestsListenerCallsCountLock.withLock { subscribeToKnockRequestsListenerUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var subscribeToKnockRequestsListenerCalled: Bool {
|
|
return subscribeToKnockRequestsListenerCallsCount > 0
|
|
}
|
|
private let subscribeToKnockRequestsListenerReceivedListenerLock = NSLock()
|
|
private var subscribeToKnockRequestsListenerUnderlyingReceivedListener: KnockRequestsListener?
|
|
open var subscribeToKnockRequestsListenerReceivedListener: KnockRequestsListener? {
|
|
get { subscribeToKnockRequestsListenerReceivedListenerLock.withLock { subscribeToKnockRequestsListenerUnderlyingReceivedListener } }
|
|
set { subscribeToKnockRequestsListenerReceivedListenerLock.withLock { subscribeToKnockRequestsListenerUnderlyingReceivedListener = newValue } }
|
|
}
|
|
private let subscribeToKnockRequestsListenerReceivedInvocationsLock = NSLock()
|
|
private var subscribeToKnockRequestsListenerUnderlyingReceivedInvocations: [KnockRequestsListener] = []
|
|
open var subscribeToKnockRequestsListenerReceivedInvocations: [KnockRequestsListener] {
|
|
get { subscribeToKnockRequestsListenerReceivedInvocationsLock.withLock { subscribeToKnockRequestsListenerUnderlyingReceivedInvocations } }
|
|
set { subscribeToKnockRequestsListenerReceivedInvocationsLock.withLock { subscribeToKnockRequestsListenerUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let subscribeToKnockRequestsListenerReturnValueLock = NSLock()
|
|
open var subscribeToKnockRequestsListenerUnderlyingReturnValue: TaskHandle!
|
|
open var subscribeToKnockRequestsListenerReturnValue: TaskHandle! {
|
|
get { subscribeToKnockRequestsListenerReturnValueLock.withLock { subscribeToKnockRequestsListenerUnderlyingReturnValue } }
|
|
set { subscribeToKnockRequestsListenerReturnValueLock.withLock { subscribeToKnockRequestsListenerUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var subscribeToKnockRequestsListenerClosure: ((KnockRequestsListener) async throws -> TaskHandle)?
|
|
|
|
open override func subscribeToKnockRequests(listener: KnockRequestsListener) async throws -> TaskHandle {
|
|
if let error = subscribeToKnockRequestsListenerThrowableError {
|
|
throw error
|
|
}
|
|
subscribeToKnockRequestsListenerCallsCountLock.withLock { subscribeToKnockRequestsListenerUnderlyingCallsCount += 1 }
|
|
subscribeToKnockRequestsListenerReceivedListener = listener
|
|
subscribeToKnockRequestsListenerReceivedInvocationsLock.withLock { subscribeToKnockRequestsListenerUnderlyingReceivedInvocations.append(listener) }
|
|
if let subscribeToKnockRequestsListenerClosure = subscribeToKnockRequestsListenerClosure {
|
|
return try await subscribeToKnockRequestsListenerClosure(listener)
|
|
} else {
|
|
return subscribeToKnockRequestsListenerReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - subscribeToRoomInfoUpdates
|
|
|
|
private let subscribeToRoomInfoUpdatesListenerCallsCountLock = NSLock()
|
|
private var subscribeToRoomInfoUpdatesListenerUnderlyingCallsCount = 0
|
|
open var subscribeToRoomInfoUpdatesListenerCallsCount: Int {
|
|
get { subscribeToRoomInfoUpdatesListenerCallsCountLock.withLock { subscribeToRoomInfoUpdatesListenerUnderlyingCallsCount } }
|
|
set { subscribeToRoomInfoUpdatesListenerCallsCountLock.withLock { subscribeToRoomInfoUpdatesListenerUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var subscribeToRoomInfoUpdatesListenerCalled: Bool {
|
|
return subscribeToRoomInfoUpdatesListenerCallsCount > 0
|
|
}
|
|
private let subscribeToRoomInfoUpdatesListenerReceivedListenerLock = NSLock()
|
|
private var subscribeToRoomInfoUpdatesListenerUnderlyingReceivedListener: RoomInfoListener?
|
|
open var subscribeToRoomInfoUpdatesListenerReceivedListener: RoomInfoListener? {
|
|
get { subscribeToRoomInfoUpdatesListenerReceivedListenerLock.withLock { subscribeToRoomInfoUpdatesListenerUnderlyingReceivedListener } }
|
|
set { subscribeToRoomInfoUpdatesListenerReceivedListenerLock.withLock { subscribeToRoomInfoUpdatesListenerUnderlyingReceivedListener = newValue } }
|
|
}
|
|
private let subscribeToRoomInfoUpdatesListenerReceivedInvocationsLock = NSLock()
|
|
private var subscribeToRoomInfoUpdatesListenerUnderlyingReceivedInvocations: [RoomInfoListener] = []
|
|
open var subscribeToRoomInfoUpdatesListenerReceivedInvocations: [RoomInfoListener] {
|
|
get { subscribeToRoomInfoUpdatesListenerReceivedInvocationsLock.withLock { subscribeToRoomInfoUpdatesListenerUnderlyingReceivedInvocations } }
|
|
set { subscribeToRoomInfoUpdatesListenerReceivedInvocationsLock.withLock { subscribeToRoomInfoUpdatesListenerUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let subscribeToRoomInfoUpdatesListenerReturnValueLock = NSLock()
|
|
open var subscribeToRoomInfoUpdatesListenerUnderlyingReturnValue: TaskHandle!
|
|
open var subscribeToRoomInfoUpdatesListenerReturnValue: TaskHandle! {
|
|
get { subscribeToRoomInfoUpdatesListenerReturnValueLock.withLock { subscribeToRoomInfoUpdatesListenerUnderlyingReturnValue } }
|
|
set { subscribeToRoomInfoUpdatesListenerReturnValueLock.withLock { subscribeToRoomInfoUpdatesListenerUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var subscribeToRoomInfoUpdatesListenerClosure: ((RoomInfoListener) -> TaskHandle)?
|
|
|
|
open override func subscribeToRoomInfoUpdates(listener: RoomInfoListener) -> TaskHandle {
|
|
subscribeToRoomInfoUpdatesListenerCallsCountLock.withLock { subscribeToRoomInfoUpdatesListenerUnderlyingCallsCount += 1 }
|
|
subscribeToRoomInfoUpdatesListenerReceivedListener = listener
|
|
subscribeToRoomInfoUpdatesListenerReceivedInvocationsLock.withLock { subscribeToRoomInfoUpdatesListenerUnderlyingReceivedInvocations.append(listener) }
|
|
if let subscribeToRoomInfoUpdatesListenerClosure = subscribeToRoomInfoUpdatesListenerClosure {
|
|
return subscribeToRoomInfoUpdatesListenerClosure(listener)
|
|
} else {
|
|
return subscribeToRoomInfoUpdatesListenerReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - subscribeToSendQueueUpdates
|
|
|
|
open var subscribeToSendQueueUpdatesListenerThrowableError: Error?
|
|
private let subscribeToSendQueueUpdatesListenerCallsCountLock = NSLock()
|
|
private var subscribeToSendQueueUpdatesListenerUnderlyingCallsCount = 0
|
|
open var subscribeToSendQueueUpdatesListenerCallsCount: Int {
|
|
get { subscribeToSendQueueUpdatesListenerCallsCountLock.withLock { subscribeToSendQueueUpdatesListenerUnderlyingCallsCount } }
|
|
set { subscribeToSendQueueUpdatesListenerCallsCountLock.withLock { subscribeToSendQueueUpdatesListenerUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var subscribeToSendQueueUpdatesListenerCalled: Bool {
|
|
return subscribeToSendQueueUpdatesListenerCallsCount > 0
|
|
}
|
|
private let subscribeToSendQueueUpdatesListenerReceivedListenerLock = NSLock()
|
|
private var subscribeToSendQueueUpdatesListenerUnderlyingReceivedListener: SendQueueListener?
|
|
open var subscribeToSendQueueUpdatesListenerReceivedListener: SendQueueListener? {
|
|
get { subscribeToSendQueueUpdatesListenerReceivedListenerLock.withLock { subscribeToSendQueueUpdatesListenerUnderlyingReceivedListener } }
|
|
set { subscribeToSendQueueUpdatesListenerReceivedListenerLock.withLock { subscribeToSendQueueUpdatesListenerUnderlyingReceivedListener = newValue } }
|
|
}
|
|
private let subscribeToSendQueueUpdatesListenerReceivedInvocationsLock = NSLock()
|
|
private var subscribeToSendQueueUpdatesListenerUnderlyingReceivedInvocations: [SendQueueListener] = []
|
|
open var subscribeToSendQueueUpdatesListenerReceivedInvocations: [SendQueueListener] {
|
|
get { subscribeToSendQueueUpdatesListenerReceivedInvocationsLock.withLock { subscribeToSendQueueUpdatesListenerUnderlyingReceivedInvocations } }
|
|
set { subscribeToSendQueueUpdatesListenerReceivedInvocationsLock.withLock { subscribeToSendQueueUpdatesListenerUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let subscribeToSendQueueUpdatesListenerReturnValueLock = NSLock()
|
|
open var subscribeToSendQueueUpdatesListenerUnderlyingReturnValue: TaskHandle!
|
|
open var subscribeToSendQueueUpdatesListenerReturnValue: TaskHandle! {
|
|
get { subscribeToSendQueueUpdatesListenerReturnValueLock.withLock { subscribeToSendQueueUpdatesListenerUnderlyingReturnValue } }
|
|
set { subscribeToSendQueueUpdatesListenerReturnValueLock.withLock { subscribeToSendQueueUpdatesListenerUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var subscribeToSendQueueUpdatesListenerClosure: ((SendQueueListener) async throws -> TaskHandle)?
|
|
|
|
open override func subscribeToSendQueueUpdates(listener: SendQueueListener) async throws -> TaskHandle {
|
|
if let error = subscribeToSendQueueUpdatesListenerThrowableError {
|
|
throw error
|
|
}
|
|
subscribeToSendQueueUpdatesListenerCallsCountLock.withLock { subscribeToSendQueueUpdatesListenerUnderlyingCallsCount += 1 }
|
|
subscribeToSendQueueUpdatesListenerReceivedListener = listener
|
|
subscribeToSendQueueUpdatesListenerReceivedInvocationsLock.withLock { subscribeToSendQueueUpdatesListenerUnderlyingReceivedInvocations.append(listener) }
|
|
if let subscribeToSendQueueUpdatesListenerClosure = subscribeToSendQueueUpdatesListenerClosure {
|
|
return try await subscribeToSendQueueUpdatesListenerClosure(listener)
|
|
} else {
|
|
return subscribeToSendQueueUpdatesListenerReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - subscribeToTypingNotifications
|
|
|
|
private let subscribeToTypingNotificationsListenerCallsCountLock = NSLock()
|
|
private var subscribeToTypingNotificationsListenerUnderlyingCallsCount = 0
|
|
open var subscribeToTypingNotificationsListenerCallsCount: Int {
|
|
get { subscribeToTypingNotificationsListenerCallsCountLock.withLock { subscribeToTypingNotificationsListenerUnderlyingCallsCount } }
|
|
set { subscribeToTypingNotificationsListenerCallsCountLock.withLock { subscribeToTypingNotificationsListenerUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var subscribeToTypingNotificationsListenerCalled: Bool {
|
|
return subscribeToTypingNotificationsListenerCallsCount > 0
|
|
}
|
|
private let subscribeToTypingNotificationsListenerReceivedListenerLock = NSLock()
|
|
private var subscribeToTypingNotificationsListenerUnderlyingReceivedListener: TypingNotificationsListener?
|
|
open var subscribeToTypingNotificationsListenerReceivedListener: TypingNotificationsListener? {
|
|
get { subscribeToTypingNotificationsListenerReceivedListenerLock.withLock { subscribeToTypingNotificationsListenerUnderlyingReceivedListener } }
|
|
set { subscribeToTypingNotificationsListenerReceivedListenerLock.withLock { subscribeToTypingNotificationsListenerUnderlyingReceivedListener = newValue } }
|
|
}
|
|
private let subscribeToTypingNotificationsListenerReceivedInvocationsLock = NSLock()
|
|
private var subscribeToTypingNotificationsListenerUnderlyingReceivedInvocations: [TypingNotificationsListener] = []
|
|
open var subscribeToTypingNotificationsListenerReceivedInvocations: [TypingNotificationsListener] {
|
|
get { subscribeToTypingNotificationsListenerReceivedInvocationsLock.withLock { subscribeToTypingNotificationsListenerUnderlyingReceivedInvocations } }
|
|
set { subscribeToTypingNotificationsListenerReceivedInvocationsLock.withLock { subscribeToTypingNotificationsListenerUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let subscribeToTypingNotificationsListenerReturnValueLock = NSLock()
|
|
open var subscribeToTypingNotificationsListenerUnderlyingReturnValue: TaskHandle!
|
|
open var subscribeToTypingNotificationsListenerReturnValue: TaskHandle! {
|
|
get { subscribeToTypingNotificationsListenerReturnValueLock.withLock { subscribeToTypingNotificationsListenerUnderlyingReturnValue } }
|
|
set { subscribeToTypingNotificationsListenerReturnValueLock.withLock { subscribeToTypingNotificationsListenerUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var subscribeToTypingNotificationsListenerClosure: ((TypingNotificationsListener) -> TaskHandle)?
|
|
|
|
open override func subscribeToTypingNotifications(listener: TypingNotificationsListener) -> TaskHandle {
|
|
subscribeToTypingNotificationsListenerCallsCountLock.withLock { subscribeToTypingNotificationsListenerUnderlyingCallsCount += 1 }
|
|
subscribeToTypingNotificationsListenerReceivedListener = listener
|
|
subscribeToTypingNotificationsListenerReceivedInvocationsLock.withLock { subscribeToTypingNotificationsListenerUnderlyingReceivedInvocations.append(listener) }
|
|
if let subscribeToTypingNotificationsListenerClosure = subscribeToTypingNotificationsListenerClosure {
|
|
return subscribeToTypingNotificationsListenerClosure(listener)
|
|
} else {
|
|
return subscribeToTypingNotificationsListenerReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - successorRoom
|
|
|
|
private let successorRoomCallsCountLock = NSLock()
|
|
private var successorRoomUnderlyingCallsCount = 0
|
|
open var successorRoomCallsCount: Int {
|
|
get { successorRoomCallsCountLock.withLock { successorRoomUnderlyingCallsCount } }
|
|
set { successorRoomCallsCountLock.withLock { successorRoomUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var successorRoomCalled: Bool {
|
|
return successorRoomCallsCount > 0
|
|
}
|
|
|
|
private let successorRoomReturnValueLock = NSLock()
|
|
open var successorRoomUnderlyingReturnValue: SuccessorRoom?
|
|
open var successorRoomReturnValue: SuccessorRoom? {
|
|
get { successorRoomReturnValueLock.withLock { successorRoomUnderlyingReturnValue } }
|
|
set { successorRoomReturnValueLock.withLock { successorRoomUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var successorRoomClosure: (() -> SuccessorRoom?)?
|
|
|
|
open override func successorRoom() -> SuccessorRoom? {
|
|
successorRoomCallsCountLock.withLock { successorRoomUnderlyingCallsCount += 1 }
|
|
if let successorRoomClosure = successorRoomClosure {
|
|
return successorRoomClosure()
|
|
} else {
|
|
return successorRoomReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - suggestedRoleForUser
|
|
|
|
open var suggestedRoleForUserUserIdThrowableError: Error?
|
|
private let suggestedRoleForUserUserIdCallsCountLock = NSLock()
|
|
private var suggestedRoleForUserUserIdUnderlyingCallsCount = 0
|
|
open var suggestedRoleForUserUserIdCallsCount: Int {
|
|
get { suggestedRoleForUserUserIdCallsCountLock.withLock { suggestedRoleForUserUserIdUnderlyingCallsCount } }
|
|
set { suggestedRoleForUserUserIdCallsCountLock.withLock { suggestedRoleForUserUserIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var suggestedRoleForUserUserIdCalled: Bool {
|
|
return suggestedRoleForUserUserIdCallsCount > 0
|
|
}
|
|
private let suggestedRoleForUserUserIdReceivedUserIdLock = NSLock()
|
|
private var suggestedRoleForUserUserIdUnderlyingReceivedUserId: String?
|
|
open var suggestedRoleForUserUserIdReceivedUserId: String? {
|
|
get { suggestedRoleForUserUserIdReceivedUserIdLock.withLock { suggestedRoleForUserUserIdUnderlyingReceivedUserId } }
|
|
set { suggestedRoleForUserUserIdReceivedUserIdLock.withLock { suggestedRoleForUserUserIdUnderlyingReceivedUserId = newValue } }
|
|
}
|
|
private let suggestedRoleForUserUserIdReceivedInvocationsLock = NSLock()
|
|
private var suggestedRoleForUserUserIdUnderlyingReceivedInvocations: [String] = []
|
|
open var suggestedRoleForUserUserIdReceivedInvocations: [String] {
|
|
get { suggestedRoleForUserUserIdReceivedInvocationsLock.withLock { suggestedRoleForUserUserIdUnderlyingReceivedInvocations } }
|
|
set { suggestedRoleForUserUserIdReceivedInvocationsLock.withLock { suggestedRoleForUserUserIdUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let suggestedRoleForUserUserIdReturnValueLock = NSLock()
|
|
open var suggestedRoleForUserUserIdUnderlyingReturnValue: RoomMemberRole!
|
|
open var suggestedRoleForUserUserIdReturnValue: RoomMemberRole! {
|
|
get { suggestedRoleForUserUserIdReturnValueLock.withLock { suggestedRoleForUserUserIdUnderlyingReturnValue } }
|
|
set { suggestedRoleForUserUserIdReturnValueLock.withLock { suggestedRoleForUserUserIdUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var suggestedRoleForUserUserIdClosure: ((String) async throws -> RoomMemberRole)?
|
|
|
|
open override func suggestedRoleForUser(userId: String) async throws -> RoomMemberRole {
|
|
if let error = suggestedRoleForUserUserIdThrowableError {
|
|
throw error
|
|
}
|
|
suggestedRoleForUserUserIdCallsCountLock.withLock { suggestedRoleForUserUserIdUnderlyingCallsCount += 1 }
|
|
suggestedRoleForUserUserIdReceivedUserId = userId
|
|
suggestedRoleForUserUserIdReceivedInvocationsLock.withLock { suggestedRoleForUserUserIdUnderlyingReceivedInvocations.append(userId) }
|
|
if let suggestedRoleForUserUserIdClosure = suggestedRoleForUserUserIdClosure {
|
|
return try await suggestedRoleForUserUserIdClosure(userId)
|
|
} else {
|
|
return suggestedRoleForUserUserIdReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - threadListService
|
|
|
|
private let threadListServiceCallsCountLock = NSLock()
|
|
private var threadListServiceUnderlyingCallsCount = 0
|
|
open var threadListServiceCallsCount: Int {
|
|
get { threadListServiceCallsCountLock.withLock { threadListServiceUnderlyingCallsCount } }
|
|
set { threadListServiceCallsCountLock.withLock { threadListServiceUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var threadListServiceCalled: Bool {
|
|
return threadListServiceCallsCount > 0
|
|
}
|
|
|
|
private let threadListServiceReturnValueLock = NSLock()
|
|
open var threadListServiceUnderlyingReturnValue: ThreadListService!
|
|
open var threadListServiceReturnValue: ThreadListService! {
|
|
get { threadListServiceReturnValueLock.withLock { threadListServiceUnderlyingReturnValue } }
|
|
set { threadListServiceReturnValueLock.withLock { threadListServiceUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var threadListServiceClosure: (() -> ThreadListService)?
|
|
|
|
open override func threadListService() -> ThreadListService {
|
|
threadListServiceCallsCountLock.withLock { threadListServiceUnderlyingCallsCount += 1 }
|
|
if let threadListServiceClosure = threadListServiceClosure {
|
|
return threadListServiceClosure()
|
|
} else {
|
|
return threadListServiceReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - timeline
|
|
|
|
open var timelineThrowableError: Error?
|
|
private let timelineCallsCountLock = NSLock()
|
|
private var timelineUnderlyingCallsCount = 0
|
|
open var timelineCallsCount: Int {
|
|
get { timelineCallsCountLock.withLock { timelineUnderlyingCallsCount } }
|
|
set { timelineCallsCountLock.withLock { timelineUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var timelineCalled: Bool {
|
|
return timelineCallsCount > 0
|
|
}
|
|
|
|
private let timelineReturnValueLock = NSLock()
|
|
open var timelineUnderlyingReturnValue: Timeline!
|
|
open var timelineReturnValue: Timeline! {
|
|
get { timelineReturnValueLock.withLock { timelineUnderlyingReturnValue } }
|
|
set { timelineReturnValueLock.withLock { timelineUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var timelineClosure: (() async throws -> Timeline)?
|
|
|
|
open override func timeline() async throws -> Timeline {
|
|
if let error = timelineThrowableError {
|
|
throw error
|
|
}
|
|
timelineCallsCountLock.withLock { timelineUnderlyingCallsCount += 1 }
|
|
if let timelineClosure = timelineClosure {
|
|
return try await timelineClosure()
|
|
} else {
|
|
return timelineReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - timelineWithConfiguration
|
|
|
|
open var timelineWithConfigurationConfigurationThrowableError: Error?
|
|
private let timelineWithConfigurationConfigurationCallsCountLock = NSLock()
|
|
private var timelineWithConfigurationConfigurationUnderlyingCallsCount = 0
|
|
open var timelineWithConfigurationConfigurationCallsCount: Int {
|
|
get { timelineWithConfigurationConfigurationCallsCountLock.withLock { timelineWithConfigurationConfigurationUnderlyingCallsCount } }
|
|
set { timelineWithConfigurationConfigurationCallsCountLock.withLock { timelineWithConfigurationConfigurationUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var timelineWithConfigurationConfigurationCalled: Bool {
|
|
return timelineWithConfigurationConfigurationCallsCount > 0
|
|
}
|
|
private let timelineWithConfigurationConfigurationReceivedConfigurationLock = NSLock()
|
|
private var timelineWithConfigurationConfigurationUnderlyingReceivedConfiguration: TimelineConfiguration?
|
|
open var timelineWithConfigurationConfigurationReceivedConfiguration: TimelineConfiguration? {
|
|
get { timelineWithConfigurationConfigurationReceivedConfigurationLock.withLock { timelineWithConfigurationConfigurationUnderlyingReceivedConfiguration } }
|
|
set { timelineWithConfigurationConfigurationReceivedConfigurationLock.withLock { timelineWithConfigurationConfigurationUnderlyingReceivedConfiguration = newValue } }
|
|
}
|
|
private let timelineWithConfigurationConfigurationReceivedInvocationsLock = NSLock()
|
|
private var timelineWithConfigurationConfigurationUnderlyingReceivedInvocations: [TimelineConfiguration] = []
|
|
open var timelineWithConfigurationConfigurationReceivedInvocations: [TimelineConfiguration] {
|
|
get { timelineWithConfigurationConfigurationReceivedInvocationsLock.withLock { timelineWithConfigurationConfigurationUnderlyingReceivedInvocations } }
|
|
set { timelineWithConfigurationConfigurationReceivedInvocationsLock.withLock { timelineWithConfigurationConfigurationUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let timelineWithConfigurationConfigurationReturnValueLock = NSLock()
|
|
open var timelineWithConfigurationConfigurationUnderlyingReturnValue: Timeline!
|
|
open var timelineWithConfigurationConfigurationReturnValue: Timeline! {
|
|
get { timelineWithConfigurationConfigurationReturnValueLock.withLock { timelineWithConfigurationConfigurationUnderlyingReturnValue } }
|
|
set { timelineWithConfigurationConfigurationReturnValueLock.withLock { timelineWithConfigurationConfigurationUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var timelineWithConfigurationConfigurationClosure: ((TimelineConfiguration) async throws -> Timeline)?
|
|
|
|
open override func timelineWithConfiguration(configuration: TimelineConfiguration) async throws -> Timeline {
|
|
if let error = timelineWithConfigurationConfigurationThrowableError {
|
|
throw error
|
|
}
|
|
timelineWithConfigurationConfigurationCallsCountLock.withLock { timelineWithConfigurationConfigurationUnderlyingCallsCount += 1 }
|
|
timelineWithConfigurationConfigurationReceivedConfiguration = configuration
|
|
timelineWithConfigurationConfigurationReceivedInvocationsLock.withLock { timelineWithConfigurationConfigurationUnderlyingReceivedInvocations.append(configuration) }
|
|
if let timelineWithConfigurationConfigurationClosure = timelineWithConfigurationConfigurationClosure {
|
|
return try await timelineWithConfigurationConfigurationClosure(configuration)
|
|
} else {
|
|
return timelineWithConfigurationConfigurationReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - topic
|
|
|
|
private let topicCallsCountLock = NSLock()
|
|
private var topicUnderlyingCallsCount = 0
|
|
open var topicCallsCount: Int {
|
|
get { topicCallsCountLock.withLock { topicUnderlyingCallsCount } }
|
|
set { topicCallsCountLock.withLock { topicUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var topicCalled: Bool {
|
|
return topicCallsCount > 0
|
|
}
|
|
|
|
private let topicReturnValueLock = NSLock()
|
|
open var topicUnderlyingReturnValue: String?
|
|
open var topicReturnValue: String? {
|
|
get { topicReturnValueLock.withLock { topicUnderlyingReturnValue } }
|
|
set { topicReturnValueLock.withLock { topicUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var topicClosure: (() -> String?)?
|
|
|
|
open override func topic() -> String? {
|
|
topicCallsCountLock.withLock { topicUnderlyingCallsCount += 1 }
|
|
if let topicClosure = topicClosure {
|
|
return topicClosure()
|
|
} else {
|
|
return topicReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - typingNotice
|
|
|
|
open var typingNoticeIsTypingThrowableError: Error?
|
|
private let typingNoticeIsTypingCallsCountLock = NSLock()
|
|
private var typingNoticeIsTypingUnderlyingCallsCount = 0
|
|
open var typingNoticeIsTypingCallsCount: Int {
|
|
get { typingNoticeIsTypingCallsCountLock.withLock { typingNoticeIsTypingUnderlyingCallsCount } }
|
|
set { typingNoticeIsTypingCallsCountLock.withLock { typingNoticeIsTypingUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var typingNoticeIsTypingCalled: Bool {
|
|
return typingNoticeIsTypingCallsCount > 0
|
|
}
|
|
private let typingNoticeIsTypingReceivedIsTypingLock = NSLock()
|
|
private var typingNoticeIsTypingUnderlyingReceivedIsTyping: Bool?
|
|
open var typingNoticeIsTypingReceivedIsTyping: Bool? {
|
|
get { typingNoticeIsTypingReceivedIsTypingLock.withLock { typingNoticeIsTypingUnderlyingReceivedIsTyping } }
|
|
set { typingNoticeIsTypingReceivedIsTypingLock.withLock { typingNoticeIsTypingUnderlyingReceivedIsTyping = newValue } }
|
|
}
|
|
private let typingNoticeIsTypingReceivedInvocationsLock = NSLock()
|
|
private var typingNoticeIsTypingUnderlyingReceivedInvocations: [Bool] = []
|
|
open var typingNoticeIsTypingReceivedInvocations: [Bool] {
|
|
get { typingNoticeIsTypingReceivedInvocationsLock.withLock { typingNoticeIsTypingUnderlyingReceivedInvocations } }
|
|
set { typingNoticeIsTypingReceivedInvocationsLock.withLock { typingNoticeIsTypingUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var typingNoticeIsTypingClosure: ((Bool) async throws -> Void)?
|
|
|
|
open override func typingNotice(isTyping: Bool) async throws {
|
|
if let error = typingNoticeIsTypingThrowableError {
|
|
throw error
|
|
}
|
|
typingNoticeIsTypingCallsCountLock.withLock { typingNoticeIsTypingUnderlyingCallsCount += 1 }
|
|
typingNoticeIsTypingReceivedIsTyping = isTyping
|
|
typingNoticeIsTypingReceivedInvocationsLock.withLock { typingNoticeIsTypingUnderlyingReceivedInvocations.append(isTyping) }
|
|
try await typingNoticeIsTypingClosure?(isTyping)
|
|
}
|
|
|
|
//MARK: - unbanUser
|
|
|
|
open var unbanUserUserIdReasonThrowableError: Error?
|
|
private let unbanUserUserIdReasonCallsCountLock = NSLock()
|
|
private var unbanUserUserIdReasonUnderlyingCallsCount = 0
|
|
open var unbanUserUserIdReasonCallsCount: Int {
|
|
get { unbanUserUserIdReasonCallsCountLock.withLock { unbanUserUserIdReasonUnderlyingCallsCount } }
|
|
set { unbanUserUserIdReasonCallsCountLock.withLock { unbanUserUserIdReasonUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var unbanUserUserIdReasonCalled: Bool {
|
|
return unbanUserUserIdReasonCallsCount > 0
|
|
}
|
|
private let unbanUserUserIdReasonReceivedArgumentsLock = NSLock()
|
|
private var unbanUserUserIdReasonUnderlyingReceivedArguments: (userId: String, reason: String?)?
|
|
open var unbanUserUserIdReasonReceivedArguments: (userId: String, reason: String?)? {
|
|
get { unbanUserUserIdReasonReceivedArgumentsLock.withLock { unbanUserUserIdReasonUnderlyingReceivedArguments } }
|
|
set { unbanUserUserIdReasonReceivedArgumentsLock.withLock { unbanUserUserIdReasonUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let unbanUserUserIdReasonReceivedInvocationsLock = NSLock()
|
|
private var unbanUserUserIdReasonUnderlyingReceivedInvocations: [(userId: String, reason: String?)] = []
|
|
open var unbanUserUserIdReasonReceivedInvocations: [(userId: String, reason: String?)] {
|
|
get { unbanUserUserIdReasonReceivedInvocationsLock.withLock { unbanUserUserIdReasonUnderlyingReceivedInvocations } }
|
|
set { unbanUserUserIdReasonReceivedInvocationsLock.withLock { unbanUserUserIdReasonUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var unbanUserUserIdReasonClosure: ((String, String?) async throws -> Void)?
|
|
|
|
open override func unbanUser(userId: String, reason: String?) async throws {
|
|
if let error = unbanUserUserIdReasonThrowableError {
|
|
throw error
|
|
}
|
|
unbanUserUserIdReasonCallsCountLock.withLock { unbanUserUserIdReasonUnderlyingCallsCount += 1 }
|
|
unbanUserUserIdReasonReceivedArguments = (userId: userId, reason: reason)
|
|
unbanUserUserIdReasonReceivedInvocationsLock.withLock { unbanUserUserIdReasonUnderlyingReceivedInvocations.append((userId: userId, reason: reason)) }
|
|
try await unbanUserUserIdReasonClosure?(userId, reason)
|
|
}
|
|
|
|
//MARK: - updateCanonicalAlias
|
|
|
|
open var updateCanonicalAliasAliasAltAliasesThrowableError: Error?
|
|
private let updateCanonicalAliasAliasAltAliasesCallsCountLock = NSLock()
|
|
private var updateCanonicalAliasAliasAltAliasesUnderlyingCallsCount = 0
|
|
open var updateCanonicalAliasAliasAltAliasesCallsCount: Int {
|
|
get { updateCanonicalAliasAliasAltAliasesCallsCountLock.withLock { updateCanonicalAliasAliasAltAliasesUnderlyingCallsCount } }
|
|
set { updateCanonicalAliasAliasAltAliasesCallsCountLock.withLock { updateCanonicalAliasAliasAltAliasesUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var updateCanonicalAliasAliasAltAliasesCalled: Bool {
|
|
return updateCanonicalAliasAliasAltAliasesCallsCount > 0
|
|
}
|
|
private let updateCanonicalAliasAliasAltAliasesReceivedArgumentsLock = NSLock()
|
|
private var updateCanonicalAliasAliasAltAliasesUnderlyingReceivedArguments: (alias: String?, altAliases: [String])?
|
|
open var updateCanonicalAliasAliasAltAliasesReceivedArguments: (alias: String?, altAliases: [String])? {
|
|
get { updateCanonicalAliasAliasAltAliasesReceivedArgumentsLock.withLock { updateCanonicalAliasAliasAltAliasesUnderlyingReceivedArguments } }
|
|
set { updateCanonicalAliasAliasAltAliasesReceivedArgumentsLock.withLock { updateCanonicalAliasAliasAltAliasesUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let updateCanonicalAliasAliasAltAliasesReceivedInvocationsLock = NSLock()
|
|
private var updateCanonicalAliasAliasAltAliasesUnderlyingReceivedInvocations: [(alias: String?, altAliases: [String])] = []
|
|
open var updateCanonicalAliasAliasAltAliasesReceivedInvocations: [(alias: String?, altAliases: [String])] {
|
|
get { updateCanonicalAliasAliasAltAliasesReceivedInvocationsLock.withLock { updateCanonicalAliasAliasAltAliasesUnderlyingReceivedInvocations } }
|
|
set { updateCanonicalAliasAliasAltAliasesReceivedInvocationsLock.withLock { updateCanonicalAliasAliasAltAliasesUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var updateCanonicalAliasAliasAltAliasesClosure: ((String?, [String]) async throws -> Void)?
|
|
|
|
open override func updateCanonicalAlias(alias: String?, altAliases: [String]) async throws {
|
|
if let error = updateCanonicalAliasAliasAltAliasesThrowableError {
|
|
throw error
|
|
}
|
|
updateCanonicalAliasAliasAltAliasesCallsCountLock.withLock { updateCanonicalAliasAliasAltAliasesUnderlyingCallsCount += 1 }
|
|
updateCanonicalAliasAliasAltAliasesReceivedArguments = (alias: alias, altAliases: altAliases)
|
|
updateCanonicalAliasAliasAltAliasesReceivedInvocationsLock.withLock { updateCanonicalAliasAliasAltAliasesUnderlyingReceivedInvocations.append((alias: alias, altAliases: altAliases)) }
|
|
try await updateCanonicalAliasAliasAltAliasesClosure?(alias, altAliases)
|
|
}
|
|
|
|
//MARK: - updateHistoryVisibility
|
|
|
|
open var updateHistoryVisibilityVisibilityThrowableError: Error?
|
|
private let updateHistoryVisibilityVisibilityCallsCountLock = NSLock()
|
|
private var updateHistoryVisibilityVisibilityUnderlyingCallsCount = 0
|
|
open var updateHistoryVisibilityVisibilityCallsCount: Int {
|
|
get { updateHistoryVisibilityVisibilityCallsCountLock.withLock { updateHistoryVisibilityVisibilityUnderlyingCallsCount } }
|
|
set { updateHistoryVisibilityVisibilityCallsCountLock.withLock { updateHistoryVisibilityVisibilityUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var updateHistoryVisibilityVisibilityCalled: Bool {
|
|
return updateHistoryVisibilityVisibilityCallsCount > 0
|
|
}
|
|
private let updateHistoryVisibilityVisibilityReceivedVisibilityLock = NSLock()
|
|
private var updateHistoryVisibilityVisibilityUnderlyingReceivedVisibility: RoomHistoryVisibility?
|
|
open var updateHistoryVisibilityVisibilityReceivedVisibility: RoomHistoryVisibility? {
|
|
get { updateHistoryVisibilityVisibilityReceivedVisibilityLock.withLock { updateHistoryVisibilityVisibilityUnderlyingReceivedVisibility } }
|
|
set { updateHistoryVisibilityVisibilityReceivedVisibilityLock.withLock { updateHistoryVisibilityVisibilityUnderlyingReceivedVisibility = newValue } }
|
|
}
|
|
private let updateHistoryVisibilityVisibilityReceivedInvocationsLock = NSLock()
|
|
private var updateHistoryVisibilityVisibilityUnderlyingReceivedInvocations: [RoomHistoryVisibility] = []
|
|
open var updateHistoryVisibilityVisibilityReceivedInvocations: [RoomHistoryVisibility] {
|
|
get { updateHistoryVisibilityVisibilityReceivedInvocationsLock.withLock { updateHistoryVisibilityVisibilityUnderlyingReceivedInvocations } }
|
|
set { updateHistoryVisibilityVisibilityReceivedInvocationsLock.withLock { updateHistoryVisibilityVisibilityUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var updateHistoryVisibilityVisibilityClosure: ((RoomHistoryVisibility) async throws -> Void)?
|
|
|
|
open override func updateHistoryVisibility(visibility: RoomHistoryVisibility) async throws {
|
|
if let error = updateHistoryVisibilityVisibilityThrowableError {
|
|
throw error
|
|
}
|
|
updateHistoryVisibilityVisibilityCallsCountLock.withLock { updateHistoryVisibilityVisibilityUnderlyingCallsCount += 1 }
|
|
updateHistoryVisibilityVisibilityReceivedVisibility = visibility
|
|
updateHistoryVisibilityVisibilityReceivedInvocationsLock.withLock { updateHistoryVisibilityVisibilityUnderlyingReceivedInvocations.append(visibility) }
|
|
try await updateHistoryVisibilityVisibilityClosure?(visibility)
|
|
}
|
|
|
|
//MARK: - updateJoinRules
|
|
|
|
open var updateJoinRulesNewRuleThrowableError: Error?
|
|
private let updateJoinRulesNewRuleCallsCountLock = NSLock()
|
|
private var updateJoinRulesNewRuleUnderlyingCallsCount = 0
|
|
open var updateJoinRulesNewRuleCallsCount: Int {
|
|
get { updateJoinRulesNewRuleCallsCountLock.withLock { updateJoinRulesNewRuleUnderlyingCallsCount } }
|
|
set { updateJoinRulesNewRuleCallsCountLock.withLock { updateJoinRulesNewRuleUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var updateJoinRulesNewRuleCalled: Bool {
|
|
return updateJoinRulesNewRuleCallsCount > 0
|
|
}
|
|
private let updateJoinRulesNewRuleReceivedNewRuleLock = NSLock()
|
|
private var updateJoinRulesNewRuleUnderlyingReceivedNewRule: JoinRule?
|
|
open var updateJoinRulesNewRuleReceivedNewRule: JoinRule? {
|
|
get { updateJoinRulesNewRuleReceivedNewRuleLock.withLock { updateJoinRulesNewRuleUnderlyingReceivedNewRule } }
|
|
set { updateJoinRulesNewRuleReceivedNewRuleLock.withLock { updateJoinRulesNewRuleUnderlyingReceivedNewRule = newValue } }
|
|
}
|
|
private let updateJoinRulesNewRuleReceivedInvocationsLock = NSLock()
|
|
private var updateJoinRulesNewRuleUnderlyingReceivedInvocations: [JoinRule] = []
|
|
open var updateJoinRulesNewRuleReceivedInvocations: [JoinRule] {
|
|
get { updateJoinRulesNewRuleReceivedInvocationsLock.withLock { updateJoinRulesNewRuleUnderlyingReceivedInvocations } }
|
|
set { updateJoinRulesNewRuleReceivedInvocationsLock.withLock { updateJoinRulesNewRuleUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var updateJoinRulesNewRuleClosure: ((JoinRule) async throws -> Void)?
|
|
|
|
open override func updateJoinRules(newRule: JoinRule) async throws {
|
|
if let error = updateJoinRulesNewRuleThrowableError {
|
|
throw error
|
|
}
|
|
updateJoinRulesNewRuleCallsCountLock.withLock { updateJoinRulesNewRuleUnderlyingCallsCount += 1 }
|
|
updateJoinRulesNewRuleReceivedNewRule = newRule
|
|
updateJoinRulesNewRuleReceivedInvocationsLock.withLock { updateJoinRulesNewRuleUnderlyingReceivedInvocations.append(newRule) }
|
|
try await updateJoinRulesNewRuleClosure?(newRule)
|
|
}
|
|
|
|
//MARK: - updatePowerLevelsForUsers
|
|
|
|
open var updatePowerLevelsForUsersUpdatesThrowableError: Error?
|
|
private let updatePowerLevelsForUsersUpdatesCallsCountLock = NSLock()
|
|
private var updatePowerLevelsForUsersUpdatesUnderlyingCallsCount = 0
|
|
open var updatePowerLevelsForUsersUpdatesCallsCount: Int {
|
|
get { updatePowerLevelsForUsersUpdatesCallsCountLock.withLock { updatePowerLevelsForUsersUpdatesUnderlyingCallsCount } }
|
|
set { updatePowerLevelsForUsersUpdatesCallsCountLock.withLock { updatePowerLevelsForUsersUpdatesUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var updatePowerLevelsForUsersUpdatesCalled: Bool {
|
|
return updatePowerLevelsForUsersUpdatesCallsCount > 0
|
|
}
|
|
private let updatePowerLevelsForUsersUpdatesReceivedUpdatesLock = NSLock()
|
|
private var updatePowerLevelsForUsersUpdatesUnderlyingReceivedUpdates: [UserPowerLevelUpdate]?
|
|
open var updatePowerLevelsForUsersUpdatesReceivedUpdates: [UserPowerLevelUpdate]? {
|
|
get { updatePowerLevelsForUsersUpdatesReceivedUpdatesLock.withLock { updatePowerLevelsForUsersUpdatesUnderlyingReceivedUpdates } }
|
|
set { updatePowerLevelsForUsersUpdatesReceivedUpdatesLock.withLock { updatePowerLevelsForUsersUpdatesUnderlyingReceivedUpdates = newValue } }
|
|
}
|
|
private let updatePowerLevelsForUsersUpdatesReceivedInvocationsLock = NSLock()
|
|
private var updatePowerLevelsForUsersUpdatesUnderlyingReceivedInvocations: [[UserPowerLevelUpdate]] = []
|
|
open var updatePowerLevelsForUsersUpdatesReceivedInvocations: [[UserPowerLevelUpdate]] {
|
|
get { updatePowerLevelsForUsersUpdatesReceivedInvocationsLock.withLock { updatePowerLevelsForUsersUpdatesUnderlyingReceivedInvocations } }
|
|
set { updatePowerLevelsForUsersUpdatesReceivedInvocationsLock.withLock { updatePowerLevelsForUsersUpdatesUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var updatePowerLevelsForUsersUpdatesClosure: (([UserPowerLevelUpdate]) async throws -> Void)?
|
|
|
|
open override func updatePowerLevelsForUsers(updates: [UserPowerLevelUpdate]) async throws {
|
|
if let error = updatePowerLevelsForUsersUpdatesThrowableError {
|
|
throw error
|
|
}
|
|
updatePowerLevelsForUsersUpdatesCallsCountLock.withLock { updatePowerLevelsForUsersUpdatesUnderlyingCallsCount += 1 }
|
|
updatePowerLevelsForUsersUpdatesReceivedUpdates = updates
|
|
updatePowerLevelsForUsersUpdatesReceivedInvocationsLock.withLock { updatePowerLevelsForUsersUpdatesUnderlyingReceivedInvocations.append(updates) }
|
|
try await updatePowerLevelsForUsersUpdatesClosure?(updates)
|
|
}
|
|
|
|
//MARK: - updateRoomVisibility
|
|
|
|
open var updateRoomVisibilityVisibilityThrowableError: Error?
|
|
private let updateRoomVisibilityVisibilityCallsCountLock = NSLock()
|
|
private var updateRoomVisibilityVisibilityUnderlyingCallsCount = 0
|
|
open var updateRoomVisibilityVisibilityCallsCount: Int {
|
|
get { updateRoomVisibilityVisibilityCallsCountLock.withLock { updateRoomVisibilityVisibilityUnderlyingCallsCount } }
|
|
set { updateRoomVisibilityVisibilityCallsCountLock.withLock { updateRoomVisibilityVisibilityUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var updateRoomVisibilityVisibilityCalled: Bool {
|
|
return updateRoomVisibilityVisibilityCallsCount > 0
|
|
}
|
|
private let updateRoomVisibilityVisibilityReceivedVisibilityLock = NSLock()
|
|
private var updateRoomVisibilityVisibilityUnderlyingReceivedVisibility: RoomVisibility?
|
|
open var updateRoomVisibilityVisibilityReceivedVisibility: RoomVisibility? {
|
|
get { updateRoomVisibilityVisibilityReceivedVisibilityLock.withLock { updateRoomVisibilityVisibilityUnderlyingReceivedVisibility } }
|
|
set { updateRoomVisibilityVisibilityReceivedVisibilityLock.withLock { updateRoomVisibilityVisibilityUnderlyingReceivedVisibility = newValue } }
|
|
}
|
|
private let updateRoomVisibilityVisibilityReceivedInvocationsLock = NSLock()
|
|
private var updateRoomVisibilityVisibilityUnderlyingReceivedInvocations: [RoomVisibility] = []
|
|
open var updateRoomVisibilityVisibilityReceivedInvocations: [RoomVisibility] {
|
|
get { updateRoomVisibilityVisibilityReceivedInvocationsLock.withLock { updateRoomVisibilityVisibilityUnderlyingReceivedInvocations } }
|
|
set { updateRoomVisibilityVisibilityReceivedInvocationsLock.withLock { updateRoomVisibilityVisibilityUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var updateRoomVisibilityVisibilityClosure: ((RoomVisibility) async throws -> Void)?
|
|
|
|
open override func updateRoomVisibility(visibility: RoomVisibility) async throws {
|
|
if let error = updateRoomVisibilityVisibilityThrowableError {
|
|
throw error
|
|
}
|
|
updateRoomVisibilityVisibilityCallsCountLock.withLock { updateRoomVisibilityVisibilityUnderlyingCallsCount += 1 }
|
|
updateRoomVisibilityVisibilityReceivedVisibility = visibility
|
|
updateRoomVisibilityVisibilityReceivedInvocationsLock.withLock { updateRoomVisibilityVisibilityUnderlyingReceivedInvocations.append(visibility) }
|
|
try await updateRoomVisibilityVisibilityClosure?(visibility)
|
|
}
|
|
|
|
//MARK: - uploadAvatar
|
|
|
|
open var uploadAvatarMimeTypeDataMediaInfoThrowableError: Error?
|
|
private let uploadAvatarMimeTypeDataMediaInfoCallsCountLock = NSLock()
|
|
private var uploadAvatarMimeTypeDataMediaInfoUnderlyingCallsCount = 0
|
|
open var uploadAvatarMimeTypeDataMediaInfoCallsCount: Int {
|
|
get { uploadAvatarMimeTypeDataMediaInfoCallsCountLock.withLock { uploadAvatarMimeTypeDataMediaInfoUnderlyingCallsCount } }
|
|
set { uploadAvatarMimeTypeDataMediaInfoCallsCountLock.withLock { uploadAvatarMimeTypeDataMediaInfoUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var uploadAvatarMimeTypeDataMediaInfoCalled: Bool {
|
|
return uploadAvatarMimeTypeDataMediaInfoCallsCount > 0
|
|
}
|
|
private let uploadAvatarMimeTypeDataMediaInfoReceivedArgumentsLock = NSLock()
|
|
private var uploadAvatarMimeTypeDataMediaInfoUnderlyingReceivedArguments: (mimeType: String, data: Data, mediaInfo: ImageInfo?)?
|
|
open var uploadAvatarMimeTypeDataMediaInfoReceivedArguments: (mimeType: String, data: Data, mediaInfo: ImageInfo?)? {
|
|
get { uploadAvatarMimeTypeDataMediaInfoReceivedArgumentsLock.withLock { uploadAvatarMimeTypeDataMediaInfoUnderlyingReceivedArguments } }
|
|
set { uploadAvatarMimeTypeDataMediaInfoReceivedArgumentsLock.withLock { uploadAvatarMimeTypeDataMediaInfoUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let uploadAvatarMimeTypeDataMediaInfoReceivedInvocationsLock = NSLock()
|
|
private var uploadAvatarMimeTypeDataMediaInfoUnderlyingReceivedInvocations: [(mimeType: String, data: Data, mediaInfo: ImageInfo?)] = []
|
|
open var uploadAvatarMimeTypeDataMediaInfoReceivedInvocations: [(mimeType: String, data: Data, mediaInfo: ImageInfo?)] {
|
|
get { uploadAvatarMimeTypeDataMediaInfoReceivedInvocationsLock.withLock { uploadAvatarMimeTypeDataMediaInfoUnderlyingReceivedInvocations } }
|
|
set { uploadAvatarMimeTypeDataMediaInfoReceivedInvocationsLock.withLock { uploadAvatarMimeTypeDataMediaInfoUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var uploadAvatarMimeTypeDataMediaInfoClosure: ((String, Data, ImageInfo?) async throws -> Void)?
|
|
|
|
open override func uploadAvatar(mimeType: String, data: Data, mediaInfo: ImageInfo?) async throws {
|
|
if let error = uploadAvatarMimeTypeDataMediaInfoThrowableError {
|
|
throw error
|
|
}
|
|
uploadAvatarMimeTypeDataMediaInfoCallsCountLock.withLock { uploadAvatarMimeTypeDataMediaInfoUnderlyingCallsCount += 1 }
|
|
uploadAvatarMimeTypeDataMediaInfoReceivedArguments = (mimeType: mimeType, data: data, mediaInfo: mediaInfo)
|
|
uploadAvatarMimeTypeDataMediaInfoReceivedInvocationsLock.withLock { uploadAvatarMimeTypeDataMediaInfoUnderlyingReceivedInvocations.append((mimeType: mimeType, data: data, mediaInfo: mediaInfo)) }
|
|
try await uploadAvatarMimeTypeDataMediaInfoClosure?(mimeType, data, mediaInfo)
|
|
}
|
|
|
|
//MARK: - withdrawVerificationAndResend
|
|
|
|
open var withdrawVerificationAndResendUserIdsSendHandleThrowableError: Error?
|
|
private let withdrawVerificationAndResendUserIdsSendHandleCallsCountLock = NSLock()
|
|
private var withdrawVerificationAndResendUserIdsSendHandleUnderlyingCallsCount = 0
|
|
open var withdrawVerificationAndResendUserIdsSendHandleCallsCount: Int {
|
|
get { withdrawVerificationAndResendUserIdsSendHandleCallsCountLock.withLock { withdrawVerificationAndResendUserIdsSendHandleUnderlyingCallsCount } }
|
|
set { withdrawVerificationAndResendUserIdsSendHandleCallsCountLock.withLock { withdrawVerificationAndResendUserIdsSendHandleUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var withdrawVerificationAndResendUserIdsSendHandleCalled: Bool {
|
|
return withdrawVerificationAndResendUserIdsSendHandleCallsCount > 0
|
|
}
|
|
private let withdrawVerificationAndResendUserIdsSendHandleReceivedArgumentsLock = NSLock()
|
|
private var withdrawVerificationAndResendUserIdsSendHandleUnderlyingReceivedArguments: (userIds: [String], sendHandle: SendHandle)?
|
|
open var withdrawVerificationAndResendUserIdsSendHandleReceivedArguments: (userIds: [String], sendHandle: SendHandle)? {
|
|
get { withdrawVerificationAndResendUserIdsSendHandleReceivedArgumentsLock.withLock { withdrawVerificationAndResendUserIdsSendHandleUnderlyingReceivedArguments } }
|
|
set { withdrawVerificationAndResendUserIdsSendHandleReceivedArgumentsLock.withLock { withdrawVerificationAndResendUserIdsSendHandleUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let withdrawVerificationAndResendUserIdsSendHandleReceivedInvocationsLock = NSLock()
|
|
private var withdrawVerificationAndResendUserIdsSendHandleUnderlyingReceivedInvocations: [(userIds: [String], sendHandle: SendHandle)] = []
|
|
open var withdrawVerificationAndResendUserIdsSendHandleReceivedInvocations: [(userIds: [String], sendHandle: SendHandle)] {
|
|
get { withdrawVerificationAndResendUserIdsSendHandleReceivedInvocationsLock.withLock { withdrawVerificationAndResendUserIdsSendHandleUnderlyingReceivedInvocations } }
|
|
set { withdrawVerificationAndResendUserIdsSendHandleReceivedInvocationsLock.withLock { withdrawVerificationAndResendUserIdsSendHandleUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var withdrawVerificationAndResendUserIdsSendHandleClosure: (([String], SendHandle) async throws -> Void)?
|
|
|
|
open override func withdrawVerificationAndResend(userIds: [String], sendHandle: SendHandle) async throws {
|
|
if let error = withdrawVerificationAndResendUserIdsSendHandleThrowableError {
|
|
throw error
|
|
}
|
|
withdrawVerificationAndResendUserIdsSendHandleCallsCountLock.withLock { withdrawVerificationAndResendUserIdsSendHandleUnderlyingCallsCount += 1 }
|
|
withdrawVerificationAndResendUserIdsSendHandleReceivedArguments = (userIds: userIds, sendHandle: sendHandle)
|
|
withdrawVerificationAndResendUserIdsSendHandleReceivedInvocationsLock.withLock { withdrawVerificationAndResendUserIdsSendHandleUnderlyingReceivedInvocations.append((userIds: userIds, sendHandle: sendHandle)) }
|
|
try await withdrawVerificationAndResendUserIdsSendHandleClosure?(userIds, sendHandle)
|
|
}
|
|
}
|
|
open class RoomDirectorySearchSDKMock: MatrixRustSDK.RoomDirectorySearch, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
|
|
//MARK: - isAtLastPage
|
|
|
|
open var isAtLastPageThrowableError: Error?
|
|
private let isAtLastPageCallsCountLock = NSLock()
|
|
private var isAtLastPageUnderlyingCallsCount = 0
|
|
open var isAtLastPageCallsCount: Int {
|
|
get { isAtLastPageCallsCountLock.withLock { isAtLastPageUnderlyingCallsCount } }
|
|
set { isAtLastPageCallsCountLock.withLock { isAtLastPageUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var isAtLastPageCalled: Bool {
|
|
return isAtLastPageCallsCount > 0
|
|
}
|
|
|
|
private let isAtLastPageReturnValueLock = NSLock()
|
|
open var isAtLastPageUnderlyingReturnValue: Bool!
|
|
open var isAtLastPageReturnValue: Bool! {
|
|
get { isAtLastPageReturnValueLock.withLock { isAtLastPageUnderlyingReturnValue } }
|
|
set { isAtLastPageReturnValueLock.withLock { isAtLastPageUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var isAtLastPageClosure: (() async throws -> Bool)?
|
|
|
|
open override func isAtLastPage() async throws -> Bool {
|
|
if let error = isAtLastPageThrowableError {
|
|
throw error
|
|
}
|
|
isAtLastPageCallsCountLock.withLock { isAtLastPageUnderlyingCallsCount += 1 }
|
|
if let isAtLastPageClosure = isAtLastPageClosure {
|
|
return try await isAtLastPageClosure()
|
|
} else {
|
|
return isAtLastPageReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - loadedPages
|
|
|
|
open var loadedPagesThrowableError: Error?
|
|
private let loadedPagesCallsCountLock = NSLock()
|
|
private var loadedPagesUnderlyingCallsCount = 0
|
|
open var loadedPagesCallsCount: Int {
|
|
get { loadedPagesCallsCountLock.withLock { loadedPagesUnderlyingCallsCount } }
|
|
set { loadedPagesCallsCountLock.withLock { loadedPagesUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var loadedPagesCalled: Bool {
|
|
return loadedPagesCallsCount > 0
|
|
}
|
|
|
|
private let loadedPagesReturnValueLock = NSLock()
|
|
open var loadedPagesUnderlyingReturnValue: UInt32!
|
|
open var loadedPagesReturnValue: UInt32! {
|
|
get { loadedPagesReturnValueLock.withLock { loadedPagesUnderlyingReturnValue } }
|
|
set { loadedPagesReturnValueLock.withLock { loadedPagesUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var loadedPagesClosure: (() async throws -> UInt32)?
|
|
|
|
open override func loadedPages() async throws -> UInt32 {
|
|
if let error = loadedPagesThrowableError {
|
|
throw error
|
|
}
|
|
loadedPagesCallsCountLock.withLock { loadedPagesUnderlyingCallsCount += 1 }
|
|
if let loadedPagesClosure = loadedPagesClosure {
|
|
return try await loadedPagesClosure()
|
|
} else {
|
|
return loadedPagesReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - nextPage
|
|
|
|
open var nextPageThrowableError: Error?
|
|
private let nextPageCallsCountLock = NSLock()
|
|
private var nextPageUnderlyingCallsCount = 0
|
|
open var nextPageCallsCount: Int {
|
|
get { nextPageCallsCountLock.withLock { nextPageUnderlyingCallsCount } }
|
|
set { nextPageCallsCountLock.withLock { nextPageUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var nextPageCalled: Bool {
|
|
return nextPageCallsCount > 0
|
|
}
|
|
open var nextPageClosure: (() async throws -> Void)?
|
|
|
|
open override func nextPage() async throws {
|
|
if let error = nextPageThrowableError {
|
|
throw error
|
|
}
|
|
nextPageCallsCountLock.withLock { nextPageUnderlyingCallsCount += 1 }
|
|
try await nextPageClosure?()
|
|
}
|
|
|
|
//MARK: - results
|
|
|
|
private let resultsListenerCallsCountLock = NSLock()
|
|
private var resultsListenerUnderlyingCallsCount = 0
|
|
open var resultsListenerCallsCount: Int {
|
|
get { resultsListenerCallsCountLock.withLock { resultsListenerUnderlyingCallsCount } }
|
|
set { resultsListenerCallsCountLock.withLock { resultsListenerUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var resultsListenerCalled: Bool {
|
|
return resultsListenerCallsCount > 0
|
|
}
|
|
private let resultsListenerReceivedListenerLock = NSLock()
|
|
private var resultsListenerUnderlyingReceivedListener: RoomDirectorySearchEntriesListener?
|
|
open var resultsListenerReceivedListener: RoomDirectorySearchEntriesListener? {
|
|
get { resultsListenerReceivedListenerLock.withLock { resultsListenerUnderlyingReceivedListener } }
|
|
set { resultsListenerReceivedListenerLock.withLock { resultsListenerUnderlyingReceivedListener = newValue } }
|
|
}
|
|
private let resultsListenerReceivedInvocationsLock = NSLock()
|
|
private var resultsListenerUnderlyingReceivedInvocations: [RoomDirectorySearchEntriesListener] = []
|
|
open var resultsListenerReceivedInvocations: [RoomDirectorySearchEntriesListener] {
|
|
get { resultsListenerReceivedInvocationsLock.withLock { resultsListenerUnderlyingReceivedInvocations } }
|
|
set { resultsListenerReceivedInvocationsLock.withLock { resultsListenerUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let resultsListenerReturnValueLock = NSLock()
|
|
open var resultsListenerUnderlyingReturnValue: TaskHandle!
|
|
open var resultsListenerReturnValue: TaskHandle! {
|
|
get { resultsListenerReturnValueLock.withLock { resultsListenerUnderlyingReturnValue } }
|
|
set { resultsListenerReturnValueLock.withLock { resultsListenerUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var resultsListenerClosure: ((RoomDirectorySearchEntriesListener) async -> TaskHandle)?
|
|
|
|
open override func results(listener: RoomDirectorySearchEntriesListener) async -> TaskHandle {
|
|
resultsListenerCallsCountLock.withLock { resultsListenerUnderlyingCallsCount += 1 }
|
|
resultsListenerReceivedListener = listener
|
|
resultsListenerReceivedInvocationsLock.withLock { resultsListenerUnderlyingReceivedInvocations.append(listener) }
|
|
if let resultsListenerClosure = resultsListenerClosure {
|
|
return await resultsListenerClosure(listener)
|
|
} else {
|
|
return resultsListenerReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - search
|
|
|
|
open var searchFilterBatchSizeViaServerNameThrowableError: Error?
|
|
private let searchFilterBatchSizeViaServerNameCallsCountLock = NSLock()
|
|
private var searchFilterBatchSizeViaServerNameUnderlyingCallsCount = 0
|
|
open var searchFilterBatchSizeViaServerNameCallsCount: Int {
|
|
get { searchFilterBatchSizeViaServerNameCallsCountLock.withLock { searchFilterBatchSizeViaServerNameUnderlyingCallsCount } }
|
|
set { searchFilterBatchSizeViaServerNameCallsCountLock.withLock { searchFilterBatchSizeViaServerNameUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var searchFilterBatchSizeViaServerNameCalled: Bool {
|
|
return searchFilterBatchSizeViaServerNameCallsCount > 0
|
|
}
|
|
private let searchFilterBatchSizeViaServerNameReceivedArgumentsLock = NSLock()
|
|
private var searchFilterBatchSizeViaServerNameUnderlyingReceivedArguments: (filter: String?, batchSize: UInt32, viaServerName: String?)?
|
|
open var searchFilterBatchSizeViaServerNameReceivedArguments: (filter: String?, batchSize: UInt32, viaServerName: String?)? {
|
|
get { searchFilterBatchSizeViaServerNameReceivedArgumentsLock.withLock { searchFilterBatchSizeViaServerNameUnderlyingReceivedArguments } }
|
|
set { searchFilterBatchSizeViaServerNameReceivedArgumentsLock.withLock { searchFilterBatchSizeViaServerNameUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let searchFilterBatchSizeViaServerNameReceivedInvocationsLock = NSLock()
|
|
private var searchFilterBatchSizeViaServerNameUnderlyingReceivedInvocations: [(filter: String?, batchSize: UInt32, viaServerName: String?)] = []
|
|
open var searchFilterBatchSizeViaServerNameReceivedInvocations: [(filter: String?, batchSize: UInt32, viaServerName: String?)] {
|
|
get { searchFilterBatchSizeViaServerNameReceivedInvocationsLock.withLock { searchFilterBatchSizeViaServerNameUnderlyingReceivedInvocations } }
|
|
set { searchFilterBatchSizeViaServerNameReceivedInvocationsLock.withLock { searchFilterBatchSizeViaServerNameUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var searchFilterBatchSizeViaServerNameClosure: ((String?, UInt32, String?) async throws -> Void)?
|
|
|
|
open override func search(filter: String?, batchSize: UInt32, viaServerName: String?) async throws {
|
|
if let error = searchFilterBatchSizeViaServerNameThrowableError {
|
|
throw error
|
|
}
|
|
searchFilterBatchSizeViaServerNameCallsCountLock.withLock { searchFilterBatchSizeViaServerNameUnderlyingCallsCount += 1 }
|
|
searchFilterBatchSizeViaServerNameReceivedArguments = (filter: filter, batchSize: batchSize, viaServerName: viaServerName)
|
|
searchFilterBatchSizeViaServerNameReceivedInvocationsLock.withLock { searchFilterBatchSizeViaServerNameUnderlyingReceivedInvocations.append((filter: filter, batchSize: batchSize, viaServerName: viaServerName)) }
|
|
try await searchFilterBatchSizeViaServerNameClosure?(filter, batchSize, viaServerName)
|
|
}
|
|
}
|
|
open class RoomListSDKMock: MatrixRustSDK.RoomList, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
|
|
//MARK: - entriesWithDynamicAdapters
|
|
|
|
private let entriesWithDynamicAdaptersPageSizeListenerCallsCountLock = NSLock()
|
|
private var entriesWithDynamicAdaptersPageSizeListenerUnderlyingCallsCount = 0
|
|
open var entriesWithDynamicAdaptersPageSizeListenerCallsCount: Int {
|
|
get { entriesWithDynamicAdaptersPageSizeListenerCallsCountLock.withLock { entriesWithDynamicAdaptersPageSizeListenerUnderlyingCallsCount } }
|
|
set { entriesWithDynamicAdaptersPageSizeListenerCallsCountLock.withLock { entriesWithDynamicAdaptersPageSizeListenerUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var entriesWithDynamicAdaptersPageSizeListenerCalled: Bool {
|
|
return entriesWithDynamicAdaptersPageSizeListenerCallsCount > 0
|
|
}
|
|
private let entriesWithDynamicAdaptersPageSizeListenerReceivedArgumentsLock = NSLock()
|
|
private var entriesWithDynamicAdaptersPageSizeListenerUnderlyingReceivedArguments: (pageSize: UInt32, listener: RoomListEntriesListener)?
|
|
open var entriesWithDynamicAdaptersPageSizeListenerReceivedArguments: (pageSize: UInt32, listener: RoomListEntriesListener)? {
|
|
get { entriesWithDynamicAdaptersPageSizeListenerReceivedArgumentsLock.withLock { entriesWithDynamicAdaptersPageSizeListenerUnderlyingReceivedArguments } }
|
|
set { entriesWithDynamicAdaptersPageSizeListenerReceivedArgumentsLock.withLock { entriesWithDynamicAdaptersPageSizeListenerUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let entriesWithDynamicAdaptersPageSizeListenerReceivedInvocationsLock = NSLock()
|
|
private var entriesWithDynamicAdaptersPageSizeListenerUnderlyingReceivedInvocations: [(pageSize: UInt32, listener: RoomListEntriesListener)] = []
|
|
open var entriesWithDynamicAdaptersPageSizeListenerReceivedInvocations: [(pageSize: UInt32, listener: RoomListEntriesListener)] {
|
|
get { entriesWithDynamicAdaptersPageSizeListenerReceivedInvocationsLock.withLock { entriesWithDynamicAdaptersPageSizeListenerUnderlyingReceivedInvocations } }
|
|
set { entriesWithDynamicAdaptersPageSizeListenerReceivedInvocationsLock.withLock { entriesWithDynamicAdaptersPageSizeListenerUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let entriesWithDynamicAdaptersPageSizeListenerReturnValueLock = NSLock()
|
|
open var entriesWithDynamicAdaptersPageSizeListenerUnderlyingReturnValue: RoomListEntriesWithDynamicAdaptersResult!
|
|
open var entriesWithDynamicAdaptersPageSizeListenerReturnValue: RoomListEntriesWithDynamicAdaptersResult! {
|
|
get { entriesWithDynamicAdaptersPageSizeListenerReturnValueLock.withLock { entriesWithDynamicAdaptersPageSizeListenerUnderlyingReturnValue } }
|
|
set { entriesWithDynamicAdaptersPageSizeListenerReturnValueLock.withLock { entriesWithDynamicAdaptersPageSizeListenerUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var entriesWithDynamicAdaptersPageSizeListenerClosure: ((UInt32, RoomListEntriesListener) -> RoomListEntriesWithDynamicAdaptersResult)?
|
|
|
|
open override func entriesWithDynamicAdapters(pageSize: UInt32, listener: RoomListEntriesListener) -> RoomListEntriesWithDynamicAdaptersResult {
|
|
entriesWithDynamicAdaptersPageSizeListenerCallsCountLock.withLock { entriesWithDynamicAdaptersPageSizeListenerUnderlyingCallsCount += 1 }
|
|
entriesWithDynamicAdaptersPageSizeListenerReceivedArguments = (pageSize: pageSize, listener: listener)
|
|
entriesWithDynamicAdaptersPageSizeListenerReceivedInvocationsLock.withLock { entriesWithDynamicAdaptersPageSizeListenerUnderlyingReceivedInvocations.append((pageSize: pageSize, listener: listener)) }
|
|
if let entriesWithDynamicAdaptersPageSizeListenerClosure = entriesWithDynamicAdaptersPageSizeListenerClosure {
|
|
return entriesWithDynamicAdaptersPageSizeListenerClosure(pageSize, listener)
|
|
} else {
|
|
return entriesWithDynamicAdaptersPageSizeListenerReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - loadingState
|
|
|
|
open var loadingStateListenerThrowableError: Error?
|
|
private let loadingStateListenerCallsCountLock = NSLock()
|
|
private var loadingStateListenerUnderlyingCallsCount = 0
|
|
open var loadingStateListenerCallsCount: Int {
|
|
get { loadingStateListenerCallsCountLock.withLock { loadingStateListenerUnderlyingCallsCount } }
|
|
set { loadingStateListenerCallsCountLock.withLock { loadingStateListenerUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var loadingStateListenerCalled: Bool {
|
|
return loadingStateListenerCallsCount > 0
|
|
}
|
|
private let loadingStateListenerReceivedListenerLock = NSLock()
|
|
private var loadingStateListenerUnderlyingReceivedListener: RoomListLoadingStateListener?
|
|
open var loadingStateListenerReceivedListener: RoomListLoadingStateListener? {
|
|
get { loadingStateListenerReceivedListenerLock.withLock { loadingStateListenerUnderlyingReceivedListener } }
|
|
set { loadingStateListenerReceivedListenerLock.withLock { loadingStateListenerUnderlyingReceivedListener = newValue } }
|
|
}
|
|
private let loadingStateListenerReceivedInvocationsLock = NSLock()
|
|
private var loadingStateListenerUnderlyingReceivedInvocations: [RoomListLoadingStateListener] = []
|
|
open var loadingStateListenerReceivedInvocations: [RoomListLoadingStateListener] {
|
|
get { loadingStateListenerReceivedInvocationsLock.withLock { loadingStateListenerUnderlyingReceivedInvocations } }
|
|
set { loadingStateListenerReceivedInvocationsLock.withLock { loadingStateListenerUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let loadingStateListenerReturnValueLock = NSLock()
|
|
open var loadingStateListenerUnderlyingReturnValue: RoomListLoadingStateResult!
|
|
open var loadingStateListenerReturnValue: RoomListLoadingStateResult! {
|
|
get { loadingStateListenerReturnValueLock.withLock { loadingStateListenerUnderlyingReturnValue } }
|
|
set { loadingStateListenerReturnValueLock.withLock { loadingStateListenerUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var loadingStateListenerClosure: ((RoomListLoadingStateListener) throws -> RoomListLoadingStateResult)?
|
|
|
|
open override func loadingState(listener: RoomListLoadingStateListener) throws -> RoomListLoadingStateResult {
|
|
if let error = loadingStateListenerThrowableError {
|
|
throw error
|
|
}
|
|
loadingStateListenerCallsCountLock.withLock { loadingStateListenerUnderlyingCallsCount += 1 }
|
|
loadingStateListenerReceivedListener = listener
|
|
loadingStateListenerReceivedInvocationsLock.withLock { loadingStateListenerUnderlyingReceivedInvocations.append(listener) }
|
|
if let loadingStateListenerClosure = loadingStateListenerClosure {
|
|
return try loadingStateListenerClosure(listener)
|
|
} else {
|
|
return loadingStateListenerReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - room
|
|
|
|
open var roomRoomIdThrowableError: Error?
|
|
private let roomRoomIdCallsCountLock = NSLock()
|
|
private var roomRoomIdUnderlyingCallsCount = 0
|
|
open var roomRoomIdCallsCount: Int {
|
|
get { roomRoomIdCallsCountLock.withLock { roomRoomIdUnderlyingCallsCount } }
|
|
set { roomRoomIdCallsCountLock.withLock { roomRoomIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var roomRoomIdCalled: Bool {
|
|
return roomRoomIdCallsCount > 0
|
|
}
|
|
private let roomRoomIdReceivedRoomIdLock = NSLock()
|
|
private var roomRoomIdUnderlyingReceivedRoomId: String?
|
|
open var roomRoomIdReceivedRoomId: String? {
|
|
get { roomRoomIdReceivedRoomIdLock.withLock { roomRoomIdUnderlyingReceivedRoomId } }
|
|
set { roomRoomIdReceivedRoomIdLock.withLock { roomRoomIdUnderlyingReceivedRoomId = newValue } }
|
|
}
|
|
private let roomRoomIdReceivedInvocationsLock = NSLock()
|
|
private var roomRoomIdUnderlyingReceivedInvocations: [String] = []
|
|
open var roomRoomIdReceivedInvocations: [String] {
|
|
get { roomRoomIdReceivedInvocationsLock.withLock { roomRoomIdUnderlyingReceivedInvocations } }
|
|
set { roomRoomIdReceivedInvocationsLock.withLock { roomRoomIdUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let roomRoomIdReturnValueLock = NSLock()
|
|
open var roomRoomIdUnderlyingReturnValue: Room!
|
|
open var roomRoomIdReturnValue: Room! {
|
|
get { roomRoomIdReturnValueLock.withLock { roomRoomIdUnderlyingReturnValue } }
|
|
set { roomRoomIdReturnValueLock.withLock { roomRoomIdUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var roomRoomIdClosure: ((String) throws -> Room)?
|
|
|
|
open override func room(roomId: String) throws -> Room {
|
|
if let error = roomRoomIdThrowableError {
|
|
throw error
|
|
}
|
|
roomRoomIdCallsCountLock.withLock { roomRoomIdUnderlyingCallsCount += 1 }
|
|
roomRoomIdReceivedRoomId = roomId
|
|
roomRoomIdReceivedInvocationsLock.withLock { roomRoomIdUnderlyingReceivedInvocations.append(roomId) }
|
|
if let roomRoomIdClosure = roomRoomIdClosure {
|
|
return try roomRoomIdClosure(roomId)
|
|
} else {
|
|
return roomRoomIdReturnValue
|
|
}
|
|
}
|
|
}
|
|
open class RoomListDynamicEntriesControllerSDKMock: MatrixRustSDK.RoomListDynamicEntriesController, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
|
|
//MARK: - addOnePage
|
|
|
|
private let addOnePageCallsCountLock = NSLock()
|
|
private var addOnePageUnderlyingCallsCount = 0
|
|
open var addOnePageCallsCount: Int {
|
|
get { addOnePageCallsCountLock.withLock { addOnePageUnderlyingCallsCount } }
|
|
set { addOnePageCallsCountLock.withLock { addOnePageUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var addOnePageCalled: Bool {
|
|
return addOnePageCallsCount > 0
|
|
}
|
|
open var addOnePageClosure: (() -> Void)?
|
|
|
|
open override func addOnePage() {
|
|
addOnePageCallsCountLock.withLock { addOnePageUnderlyingCallsCount += 1 }
|
|
addOnePageClosure?()
|
|
}
|
|
|
|
//MARK: - resetToOnePage
|
|
|
|
private let resetToOnePageCallsCountLock = NSLock()
|
|
private var resetToOnePageUnderlyingCallsCount = 0
|
|
open var resetToOnePageCallsCount: Int {
|
|
get { resetToOnePageCallsCountLock.withLock { resetToOnePageUnderlyingCallsCount } }
|
|
set { resetToOnePageCallsCountLock.withLock { resetToOnePageUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var resetToOnePageCalled: Bool {
|
|
return resetToOnePageCallsCount > 0
|
|
}
|
|
open var resetToOnePageClosure: (() -> Void)?
|
|
|
|
open override func resetToOnePage() {
|
|
resetToOnePageCallsCountLock.withLock { resetToOnePageUnderlyingCallsCount += 1 }
|
|
resetToOnePageClosure?()
|
|
}
|
|
|
|
//MARK: - setFilter
|
|
|
|
private let setFilterKindCallsCountLock = NSLock()
|
|
private var setFilterKindUnderlyingCallsCount = 0
|
|
open var setFilterKindCallsCount: Int {
|
|
get { setFilterKindCallsCountLock.withLock { setFilterKindUnderlyingCallsCount } }
|
|
set { setFilterKindCallsCountLock.withLock { setFilterKindUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var setFilterKindCalled: Bool {
|
|
return setFilterKindCallsCount > 0
|
|
}
|
|
private let setFilterKindReceivedKindLock = NSLock()
|
|
private var setFilterKindUnderlyingReceivedKind: RoomListEntriesDynamicFilterKind?
|
|
open var setFilterKindReceivedKind: RoomListEntriesDynamicFilterKind? {
|
|
get { setFilterKindReceivedKindLock.withLock { setFilterKindUnderlyingReceivedKind } }
|
|
set { setFilterKindReceivedKindLock.withLock { setFilterKindUnderlyingReceivedKind = newValue } }
|
|
}
|
|
private let setFilterKindReceivedInvocationsLock = NSLock()
|
|
private var setFilterKindUnderlyingReceivedInvocations: [RoomListEntriesDynamicFilterKind] = []
|
|
open var setFilterKindReceivedInvocations: [RoomListEntriesDynamicFilterKind] {
|
|
get { setFilterKindReceivedInvocationsLock.withLock { setFilterKindUnderlyingReceivedInvocations } }
|
|
set { setFilterKindReceivedInvocationsLock.withLock { setFilterKindUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let setFilterKindReturnValueLock = NSLock()
|
|
open var setFilterKindUnderlyingReturnValue: Bool!
|
|
open var setFilterKindReturnValue: Bool! {
|
|
get { setFilterKindReturnValueLock.withLock { setFilterKindUnderlyingReturnValue } }
|
|
set { setFilterKindReturnValueLock.withLock { setFilterKindUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var setFilterKindClosure: ((RoomListEntriesDynamicFilterKind) -> Bool)?
|
|
|
|
open override func setFilter(kind: RoomListEntriesDynamicFilterKind) -> Bool {
|
|
setFilterKindCallsCountLock.withLock { setFilterKindUnderlyingCallsCount += 1 }
|
|
setFilterKindReceivedKind = kind
|
|
setFilterKindReceivedInvocationsLock.withLock { setFilterKindUnderlyingReceivedInvocations.append(kind) }
|
|
if let setFilterKindClosure = setFilterKindClosure {
|
|
return setFilterKindClosure(kind)
|
|
} else {
|
|
return setFilterKindReturnValue
|
|
}
|
|
}
|
|
}
|
|
open class RoomListEntriesWithDynamicAdaptersResultSDKMock: MatrixRustSDK.RoomListEntriesWithDynamicAdaptersResult, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
|
|
//MARK: - controller
|
|
|
|
private let controllerCallsCountLock = NSLock()
|
|
private var controllerUnderlyingCallsCount = 0
|
|
open var controllerCallsCount: Int {
|
|
get { controllerCallsCountLock.withLock { controllerUnderlyingCallsCount } }
|
|
set { controllerCallsCountLock.withLock { controllerUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var controllerCalled: Bool {
|
|
return controllerCallsCount > 0
|
|
}
|
|
|
|
private let controllerReturnValueLock = NSLock()
|
|
open var controllerUnderlyingReturnValue: RoomListDynamicEntriesController!
|
|
open var controllerReturnValue: RoomListDynamicEntriesController! {
|
|
get { controllerReturnValueLock.withLock { controllerUnderlyingReturnValue } }
|
|
set { controllerReturnValueLock.withLock { controllerUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var controllerClosure: (() -> RoomListDynamicEntriesController)?
|
|
|
|
open override func controller() -> RoomListDynamicEntriesController {
|
|
controllerCallsCountLock.withLock { controllerUnderlyingCallsCount += 1 }
|
|
if let controllerClosure = controllerClosure {
|
|
return controllerClosure()
|
|
} else {
|
|
return controllerReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - entriesStream
|
|
|
|
private let entriesStreamCallsCountLock = NSLock()
|
|
private var entriesStreamUnderlyingCallsCount = 0
|
|
open var entriesStreamCallsCount: Int {
|
|
get { entriesStreamCallsCountLock.withLock { entriesStreamUnderlyingCallsCount } }
|
|
set { entriesStreamCallsCountLock.withLock { entriesStreamUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var entriesStreamCalled: Bool {
|
|
return entriesStreamCallsCount > 0
|
|
}
|
|
|
|
private let entriesStreamReturnValueLock = NSLock()
|
|
open var entriesStreamUnderlyingReturnValue: TaskHandle!
|
|
open var entriesStreamReturnValue: TaskHandle! {
|
|
get { entriesStreamReturnValueLock.withLock { entriesStreamUnderlyingReturnValue } }
|
|
set { entriesStreamReturnValueLock.withLock { entriesStreamUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var entriesStreamClosure: (() -> TaskHandle)?
|
|
|
|
open override func entriesStream() -> TaskHandle {
|
|
entriesStreamCallsCountLock.withLock { entriesStreamUnderlyingCallsCount += 1 }
|
|
if let entriesStreamClosure = entriesStreamClosure {
|
|
return entriesStreamClosure()
|
|
} else {
|
|
return entriesStreamReturnValue
|
|
}
|
|
}
|
|
}
|
|
open class RoomListServiceSDKMock: MatrixRustSDK.RoomListService, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
|
|
//MARK: - allRooms
|
|
|
|
open var allRoomsThrowableError: Error?
|
|
private let allRoomsCallsCountLock = NSLock()
|
|
private var allRoomsUnderlyingCallsCount = 0
|
|
open var allRoomsCallsCount: Int {
|
|
get { allRoomsCallsCountLock.withLock { allRoomsUnderlyingCallsCount } }
|
|
set { allRoomsCallsCountLock.withLock { allRoomsUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var allRoomsCalled: Bool {
|
|
return allRoomsCallsCount > 0
|
|
}
|
|
|
|
private let allRoomsReturnValueLock = NSLock()
|
|
open var allRoomsUnderlyingReturnValue: RoomList!
|
|
open var allRoomsReturnValue: RoomList! {
|
|
get { allRoomsReturnValueLock.withLock { allRoomsUnderlyingReturnValue } }
|
|
set { allRoomsReturnValueLock.withLock { allRoomsUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var allRoomsClosure: (() async throws -> RoomList)?
|
|
|
|
open override func allRooms() async throws -> RoomList {
|
|
if let error = allRoomsThrowableError {
|
|
throw error
|
|
}
|
|
allRoomsCallsCountLock.withLock { allRoomsUnderlyingCallsCount += 1 }
|
|
if let allRoomsClosure = allRoomsClosure {
|
|
return try await allRoomsClosure()
|
|
} else {
|
|
return allRoomsReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - room
|
|
|
|
open var roomRoomIdThrowableError: Error?
|
|
private let roomRoomIdCallsCountLock = NSLock()
|
|
private var roomRoomIdUnderlyingCallsCount = 0
|
|
open var roomRoomIdCallsCount: Int {
|
|
get { roomRoomIdCallsCountLock.withLock { roomRoomIdUnderlyingCallsCount } }
|
|
set { roomRoomIdCallsCountLock.withLock { roomRoomIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var roomRoomIdCalled: Bool {
|
|
return roomRoomIdCallsCount > 0
|
|
}
|
|
private let roomRoomIdReceivedRoomIdLock = NSLock()
|
|
private var roomRoomIdUnderlyingReceivedRoomId: String?
|
|
open var roomRoomIdReceivedRoomId: String? {
|
|
get { roomRoomIdReceivedRoomIdLock.withLock { roomRoomIdUnderlyingReceivedRoomId } }
|
|
set { roomRoomIdReceivedRoomIdLock.withLock { roomRoomIdUnderlyingReceivedRoomId = newValue } }
|
|
}
|
|
private let roomRoomIdReceivedInvocationsLock = NSLock()
|
|
private var roomRoomIdUnderlyingReceivedInvocations: [String] = []
|
|
open var roomRoomIdReceivedInvocations: [String] {
|
|
get { roomRoomIdReceivedInvocationsLock.withLock { roomRoomIdUnderlyingReceivedInvocations } }
|
|
set { roomRoomIdReceivedInvocationsLock.withLock { roomRoomIdUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let roomRoomIdReturnValueLock = NSLock()
|
|
open var roomRoomIdUnderlyingReturnValue: Room!
|
|
open var roomRoomIdReturnValue: Room! {
|
|
get { roomRoomIdReturnValueLock.withLock { roomRoomIdUnderlyingReturnValue } }
|
|
set { roomRoomIdReturnValueLock.withLock { roomRoomIdUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var roomRoomIdClosure: ((String) throws -> Room)?
|
|
|
|
open override func room(roomId: String) throws -> Room {
|
|
if let error = roomRoomIdThrowableError {
|
|
throw error
|
|
}
|
|
roomRoomIdCallsCountLock.withLock { roomRoomIdUnderlyingCallsCount += 1 }
|
|
roomRoomIdReceivedRoomId = roomId
|
|
roomRoomIdReceivedInvocationsLock.withLock { roomRoomIdUnderlyingReceivedInvocations.append(roomId) }
|
|
if let roomRoomIdClosure = roomRoomIdClosure {
|
|
return try roomRoomIdClosure(roomId)
|
|
} else {
|
|
return roomRoomIdReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - state
|
|
|
|
private let stateListenerCallsCountLock = NSLock()
|
|
private var stateListenerUnderlyingCallsCount = 0
|
|
open var stateListenerCallsCount: Int {
|
|
get { stateListenerCallsCountLock.withLock { stateListenerUnderlyingCallsCount } }
|
|
set { stateListenerCallsCountLock.withLock { stateListenerUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var stateListenerCalled: Bool {
|
|
return stateListenerCallsCount > 0
|
|
}
|
|
private let stateListenerReceivedListenerLock = NSLock()
|
|
private var stateListenerUnderlyingReceivedListener: RoomListServiceStateListener?
|
|
open var stateListenerReceivedListener: RoomListServiceStateListener? {
|
|
get { stateListenerReceivedListenerLock.withLock { stateListenerUnderlyingReceivedListener } }
|
|
set { stateListenerReceivedListenerLock.withLock { stateListenerUnderlyingReceivedListener = newValue } }
|
|
}
|
|
private let stateListenerReceivedInvocationsLock = NSLock()
|
|
private var stateListenerUnderlyingReceivedInvocations: [RoomListServiceStateListener] = []
|
|
open var stateListenerReceivedInvocations: [RoomListServiceStateListener] {
|
|
get { stateListenerReceivedInvocationsLock.withLock { stateListenerUnderlyingReceivedInvocations } }
|
|
set { stateListenerReceivedInvocationsLock.withLock { stateListenerUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let stateListenerReturnValueLock = NSLock()
|
|
open var stateListenerUnderlyingReturnValue: TaskHandle!
|
|
open var stateListenerReturnValue: TaskHandle! {
|
|
get { stateListenerReturnValueLock.withLock { stateListenerUnderlyingReturnValue } }
|
|
set { stateListenerReturnValueLock.withLock { stateListenerUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var stateListenerClosure: ((RoomListServiceStateListener) -> TaskHandle)?
|
|
|
|
open override func state(listener: RoomListServiceStateListener) -> TaskHandle {
|
|
stateListenerCallsCountLock.withLock { stateListenerUnderlyingCallsCount += 1 }
|
|
stateListenerReceivedListener = listener
|
|
stateListenerReceivedInvocationsLock.withLock { stateListenerUnderlyingReceivedInvocations.append(listener) }
|
|
if let stateListenerClosure = stateListenerClosure {
|
|
return stateListenerClosure(listener)
|
|
} else {
|
|
return stateListenerReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - subscribeToRooms
|
|
|
|
open var subscribeToRoomsRoomIdsThrowableError: Error?
|
|
private let subscribeToRoomsRoomIdsCallsCountLock = NSLock()
|
|
private var subscribeToRoomsRoomIdsUnderlyingCallsCount = 0
|
|
open var subscribeToRoomsRoomIdsCallsCount: Int {
|
|
get { subscribeToRoomsRoomIdsCallsCountLock.withLock { subscribeToRoomsRoomIdsUnderlyingCallsCount } }
|
|
set { subscribeToRoomsRoomIdsCallsCountLock.withLock { subscribeToRoomsRoomIdsUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var subscribeToRoomsRoomIdsCalled: Bool {
|
|
return subscribeToRoomsRoomIdsCallsCount > 0
|
|
}
|
|
private let subscribeToRoomsRoomIdsReceivedRoomIdsLock = NSLock()
|
|
private var subscribeToRoomsRoomIdsUnderlyingReceivedRoomIds: [String]?
|
|
open var subscribeToRoomsRoomIdsReceivedRoomIds: [String]? {
|
|
get { subscribeToRoomsRoomIdsReceivedRoomIdsLock.withLock { subscribeToRoomsRoomIdsUnderlyingReceivedRoomIds } }
|
|
set { subscribeToRoomsRoomIdsReceivedRoomIdsLock.withLock { subscribeToRoomsRoomIdsUnderlyingReceivedRoomIds = newValue } }
|
|
}
|
|
private let subscribeToRoomsRoomIdsReceivedInvocationsLock = NSLock()
|
|
private var subscribeToRoomsRoomIdsUnderlyingReceivedInvocations: [[String]] = []
|
|
open var subscribeToRoomsRoomIdsReceivedInvocations: [[String]] {
|
|
get { subscribeToRoomsRoomIdsReceivedInvocationsLock.withLock { subscribeToRoomsRoomIdsUnderlyingReceivedInvocations } }
|
|
set { subscribeToRoomsRoomIdsReceivedInvocationsLock.withLock { subscribeToRoomsRoomIdsUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var subscribeToRoomsRoomIdsClosure: (([String]) async throws -> Void)?
|
|
|
|
open override func subscribeToRooms(roomIds: [String]) async throws {
|
|
if let error = subscribeToRoomsRoomIdsThrowableError {
|
|
throw error
|
|
}
|
|
subscribeToRoomsRoomIdsCallsCountLock.withLock { subscribeToRoomsRoomIdsUnderlyingCallsCount += 1 }
|
|
subscribeToRoomsRoomIdsReceivedRoomIds = roomIds
|
|
subscribeToRoomsRoomIdsReceivedInvocationsLock.withLock { subscribeToRoomsRoomIdsUnderlyingReceivedInvocations.append(roomIds) }
|
|
try await subscribeToRoomsRoomIdsClosure?(roomIds)
|
|
}
|
|
|
|
//MARK: - syncIndicator
|
|
|
|
private let syncIndicatorDelayBeforeShowingInMsDelayBeforeHidingInMsListenerCallsCountLock = NSLock()
|
|
private var syncIndicatorDelayBeforeShowingInMsDelayBeforeHidingInMsListenerUnderlyingCallsCount = 0
|
|
open var syncIndicatorDelayBeforeShowingInMsDelayBeforeHidingInMsListenerCallsCount: Int {
|
|
get { syncIndicatorDelayBeforeShowingInMsDelayBeforeHidingInMsListenerCallsCountLock.withLock { syncIndicatorDelayBeforeShowingInMsDelayBeforeHidingInMsListenerUnderlyingCallsCount } }
|
|
set { syncIndicatorDelayBeforeShowingInMsDelayBeforeHidingInMsListenerCallsCountLock.withLock { syncIndicatorDelayBeforeShowingInMsDelayBeforeHidingInMsListenerUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var syncIndicatorDelayBeforeShowingInMsDelayBeforeHidingInMsListenerCalled: Bool {
|
|
return syncIndicatorDelayBeforeShowingInMsDelayBeforeHidingInMsListenerCallsCount > 0
|
|
}
|
|
private let syncIndicatorDelayBeforeShowingInMsDelayBeforeHidingInMsListenerReceivedArgumentsLock = NSLock()
|
|
private var syncIndicatorDelayBeforeShowingInMsDelayBeforeHidingInMsListenerUnderlyingReceivedArguments: (delayBeforeShowingInMs: UInt32, delayBeforeHidingInMs: UInt32, listener: RoomListServiceSyncIndicatorListener)?
|
|
open var syncIndicatorDelayBeforeShowingInMsDelayBeforeHidingInMsListenerReceivedArguments: (delayBeforeShowingInMs: UInt32, delayBeforeHidingInMs: UInt32, listener: RoomListServiceSyncIndicatorListener)? {
|
|
get { syncIndicatorDelayBeforeShowingInMsDelayBeforeHidingInMsListenerReceivedArgumentsLock.withLock { syncIndicatorDelayBeforeShowingInMsDelayBeforeHidingInMsListenerUnderlyingReceivedArguments } }
|
|
set { syncIndicatorDelayBeforeShowingInMsDelayBeforeHidingInMsListenerReceivedArgumentsLock.withLock { syncIndicatorDelayBeforeShowingInMsDelayBeforeHidingInMsListenerUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let syncIndicatorDelayBeforeShowingInMsDelayBeforeHidingInMsListenerReceivedInvocationsLock = NSLock()
|
|
private var syncIndicatorDelayBeforeShowingInMsDelayBeforeHidingInMsListenerUnderlyingReceivedInvocations: [(delayBeforeShowingInMs: UInt32, delayBeforeHidingInMs: UInt32, listener: RoomListServiceSyncIndicatorListener)] = []
|
|
open var syncIndicatorDelayBeforeShowingInMsDelayBeforeHidingInMsListenerReceivedInvocations: [(delayBeforeShowingInMs: UInt32, delayBeforeHidingInMs: UInt32, listener: RoomListServiceSyncIndicatorListener)] {
|
|
get { syncIndicatorDelayBeforeShowingInMsDelayBeforeHidingInMsListenerReceivedInvocationsLock.withLock { syncIndicatorDelayBeforeShowingInMsDelayBeforeHidingInMsListenerUnderlyingReceivedInvocations } }
|
|
set { syncIndicatorDelayBeforeShowingInMsDelayBeforeHidingInMsListenerReceivedInvocationsLock.withLock { syncIndicatorDelayBeforeShowingInMsDelayBeforeHidingInMsListenerUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let syncIndicatorDelayBeforeShowingInMsDelayBeforeHidingInMsListenerReturnValueLock = NSLock()
|
|
open var syncIndicatorDelayBeforeShowingInMsDelayBeforeHidingInMsListenerUnderlyingReturnValue: TaskHandle!
|
|
open var syncIndicatorDelayBeforeShowingInMsDelayBeforeHidingInMsListenerReturnValue: TaskHandle! {
|
|
get { syncIndicatorDelayBeforeShowingInMsDelayBeforeHidingInMsListenerReturnValueLock.withLock { syncIndicatorDelayBeforeShowingInMsDelayBeforeHidingInMsListenerUnderlyingReturnValue } }
|
|
set { syncIndicatorDelayBeforeShowingInMsDelayBeforeHidingInMsListenerReturnValueLock.withLock { syncIndicatorDelayBeforeShowingInMsDelayBeforeHidingInMsListenerUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var syncIndicatorDelayBeforeShowingInMsDelayBeforeHidingInMsListenerClosure: ((UInt32, UInt32, RoomListServiceSyncIndicatorListener) -> TaskHandle)?
|
|
|
|
open override func syncIndicator(delayBeforeShowingInMs: UInt32, delayBeforeHidingInMs: UInt32, listener: RoomListServiceSyncIndicatorListener) -> TaskHandle {
|
|
syncIndicatorDelayBeforeShowingInMsDelayBeforeHidingInMsListenerCallsCountLock.withLock { syncIndicatorDelayBeforeShowingInMsDelayBeforeHidingInMsListenerUnderlyingCallsCount += 1 }
|
|
syncIndicatorDelayBeforeShowingInMsDelayBeforeHidingInMsListenerReceivedArguments = (delayBeforeShowingInMs: delayBeforeShowingInMs, delayBeforeHidingInMs: delayBeforeHidingInMs, listener: listener)
|
|
syncIndicatorDelayBeforeShowingInMsDelayBeforeHidingInMsListenerReceivedInvocationsLock.withLock { syncIndicatorDelayBeforeShowingInMsDelayBeforeHidingInMsListenerUnderlyingReceivedInvocations.append((delayBeforeShowingInMs: delayBeforeShowingInMs, delayBeforeHidingInMs: delayBeforeHidingInMs, listener: listener)) }
|
|
if let syncIndicatorDelayBeforeShowingInMsDelayBeforeHidingInMsListenerClosure = syncIndicatorDelayBeforeShowingInMsDelayBeforeHidingInMsListenerClosure {
|
|
return syncIndicatorDelayBeforeShowingInMsDelayBeforeHidingInMsListenerClosure(delayBeforeShowingInMs, delayBeforeHidingInMs, listener)
|
|
} else {
|
|
return syncIndicatorDelayBeforeShowingInMsDelayBeforeHidingInMsListenerReturnValue
|
|
}
|
|
}
|
|
}
|
|
open class RoomMembersIteratorSDKMock: MatrixRustSDK.RoomMembersIterator, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
|
|
//MARK: - len
|
|
|
|
private let lenCallsCountLock = NSLock()
|
|
private var lenUnderlyingCallsCount = 0
|
|
open var lenCallsCount: Int {
|
|
get { lenCallsCountLock.withLock { lenUnderlyingCallsCount } }
|
|
set { lenCallsCountLock.withLock { lenUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var lenCalled: Bool {
|
|
return lenCallsCount > 0
|
|
}
|
|
|
|
private let lenReturnValueLock = NSLock()
|
|
open var lenUnderlyingReturnValue: UInt32!
|
|
open var lenReturnValue: UInt32! {
|
|
get { lenReturnValueLock.withLock { lenUnderlyingReturnValue } }
|
|
set { lenReturnValueLock.withLock { lenUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var lenClosure: (() -> UInt32)?
|
|
|
|
open override func len() -> UInt32 {
|
|
lenCallsCountLock.withLock { lenUnderlyingCallsCount += 1 }
|
|
if let lenClosure = lenClosure {
|
|
return lenClosure()
|
|
} else {
|
|
return lenReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - nextChunk
|
|
|
|
private let nextChunkChunkSizeCallsCountLock = NSLock()
|
|
private var nextChunkChunkSizeUnderlyingCallsCount = 0
|
|
open var nextChunkChunkSizeCallsCount: Int {
|
|
get { nextChunkChunkSizeCallsCountLock.withLock { nextChunkChunkSizeUnderlyingCallsCount } }
|
|
set { nextChunkChunkSizeCallsCountLock.withLock { nextChunkChunkSizeUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var nextChunkChunkSizeCalled: Bool {
|
|
return nextChunkChunkSizeCallsCount > 0
|
|
}
|
|
private let nextChunkChunkSizeReceivedChunkSizeLock = NSLock()
|
|
private var nextChunkChunkSizeUnderlyingReceivedChunkSize: UInt32?
|
|
open var nextChunkChunkSizeReceivedChunkSize: UInt32? {
|
|
get { nextChunkChunkSizeReceivedChunkSizeLock.withLock { nextChunkChunkSizeUnderlyingReceivedChunkSize } }
|
|
set { nextChunkChunkSizeReceivedChunkSizeLock.withLock { nextChunkChunkSizeUnderlyingReceivedChunkSize = newValue } }
|
|
}
|
|
private let nextChunkChunkSizeReceivedInvocationsLock = NSLock()
|
|
private var nextChunkChunkSizeUnderlyingReceivedInvocations: [UInt32] = []
|
|
open var nextChunkChunkSizeReceivedInvocations: [UInt32] {
|
|
get { nextChunkChunkSizeReceivedInvocationsLock.withLock { nextChunkChunkSizeUnderlyingReceivedInvocations } }
|
|
set { nextChunkChunkSizeReceivedInvocationsLock.withLock { nextChunkChunkSizeUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let nextChunkChunkSizeReturnValueLock = NSLock()
|
|
open var nextChunkChunkSizeUnderlyingReturnValue: [RoomMember]?
|
|
open var nextChunkChunkSizeReturnValue: [RoomMember]? {
|
|
get { nextChunkChunkSizeReturnValueLock.withLock { nextChunkChunkSizeUnderlyingReturnValue } }
|
|
set { nextChunkChunkSizeReturnValueLock.withLock { nextChunkChunkSizeUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var nextChunkChunkSizeClosure: ((UInt32) -> [RoomMember]?)?
|
|
|
|
open override func nextChunk(chunkSize: UInt32) -> [RoomMember]? {
|
|
nextChunkChunkSizeCallsCountLock.withLock { nextChunkChunkSizeUnderlyingCallsCount += 1 }
|
|
nextChunkChunkSizeReceivedChunkSize = chunkSize
|
|
nextChunkChunkSizeReceivedInvocationsLock.withLock { nextChunkChunkSizeUnderlyingReceivedInvocations.append(chunkSize) }
|
|
if let nextChunkChunkSizeClosure = nextChunkChunkSizeClosure {
|
|
return nextChunkChunkSizeClosure(chunkSize)
|
|
} else {
|
|
return nextChunkChunkSizeReturnValue
|
|
}
|
|
}
|
|
}
|
|
open class RoomMessageEventContentWithoutRelationSDKMock: MatrixRustSDK.RoomMessageEventContentWithoutRelation, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
|
|
//MARK: - withMentions
|
|
|
|
private let withMentionsMentionsCallsCountLock = NSLock()
|
|
private var withMentionsMentionsUnderlyingCallsCount = 0
|
|
open var withMentionsMentionsCallsCount: Int {
|
|
get { withMentionsMentionsCallsCountLock.withLock { withMentionsMentionsUnderlyingCallsCount } }
|
|
set { withMentionsMentionsCallsCountLock.withLock { withMentionsMentionsUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var withMentionsMentionsCalled: Bool {
|
|
return withMentionsMentionsCallsCount > 0
|
|
}
|
|
private let withMentionsMentionsReceivedMentionsLock = NSLock()
|
|
private var withMentionsMentionsUnderlyingReceivedMentions: Mentions?
|
|
open var withMentionsMentionsReceivedMentions: Mentions? {
|
|
get { withMentionsMentionsReceivedMentionsLock.withLock { withMentionsMentionsUnderlyingReceivedMentions } }
|
|
set { withMentionsMentionsReceivedMentionsLock.withLock { withMentionsMentionsUnderlyingReceivedMentions = newValue } }
|
|
}
|
|
private let withMentionsMentionsReceivedInvocationsLock = NSLock()
|
|
private var withMentionsMentionsUnderlyingReceivedInvocations: [Mentions] = []
|
|
open var withMentionsMentionsReceivedInvocations: [Mentions] {
|
|
get { withMentionsMentionsReceivedInvocationsLock.withLock { withMentionsMentionsUnderlyingReceivedInvocations } }
|
|
set { withMentionsMentionsReceivedInvocationsLock.withLock { withMentionsMentionsUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let withMentionsMentionsReturnValueLock = NSLock()
|
|
open var withMentionsMentionsUnderlyingReturnValue: RoomMessageEventContentWithoutRelation!
|
|
open var withMentionsMentionsReturnValue: RoomMessageEventContentWithoutRelation! {
|
|
get { withMentionsMentionsReturnValueLock.withLock { withMentionsMentionsUnderlyingReturnValue } }
|
|
set { withMentionsMentionsReturnValueLock.withLock { withMentionsMentionsUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var withMentionsMentionsClosure: ((Mentions) -> RoomMessageEventContentWithoutRelation)?
|
|
|
|
open override func withMentions(mentions: Mentions) -> RoomMessageEventContentWithoutRelation {
|
|
withMentionsMentionsCallsCountLock.withLock { withMentionsMentionsUnderlyingCallsCount += 1 }
|
|
withMentionsMentionsReceivedMentions = mentions
|
|
withMentionsMentionsReceivedInvocationsLock.withLock { withMentionsMentionsUnderlyingReceivedInvocations.append(mentions) }
|
|
if let withMentionsMentionsClosure = withMentionsMentionsClosure {
|
|
return withMentionsMentionsClosure(mentions)
|
|
} else {
|
|
return withMentionsMentionsReturnValue
|
|
}
|
|
}
|
|
}
|
|
open class RoomPowerLevelsSDKMock: MatrixRustSDK.RoomPowerLevels, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
|
|
//MARK: - canOwnUserBan
|
|
|
|
private let canOwnUserBanCallsCountLock = NSLock()
|
|
private var canOwnUserBanUnderlyingCallsCount = 0
|
|
open var canOwnUserBanCallsCount: Int {
|
|
get { canOwnUserBanCallsCountLock.withLock { canOwnUserBanUnderlyingCallsCount } }
|
|
set { canOwnUserBanCallsCountLock.withLock { canOwnUserBanUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var canOwnUserBanCalled: Bool {
|
|
return canOwnUserBanCallsCount > 0
|
|
}
|
|
|
|
private let canOwnUserBanReturnValueLock = NSLock()
|
|
open var canOwnUserBanUnderlyingReturnValue: Bool!
|
|
open var canOwnUserBanReturnValue: Bool! {
|
|
get { canOwnUserBanReturnValueLock.withLock { canOwnUserBanUnderlyingReturnValue } }
|
|
set { canOwnUserBanReturnValueLock.withLock { canOwnUserBanUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var canOwnUserBanClosure: (() -> Bool)?
|
|
|
|
open override func canOwnUserBan() -> Bool {
|
|
canOwnUserBanCallsCountLock.withLock { canOwnUserBanUnderlyingCallsCount += 1 }
|
|
if let canOwnUserBanClosure = canOwnUserBanClosure {
|
|
return canOwnUserBanClosure()
|
|
} else {
|
|
return canOwnUserBanReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - canOwnUserInvite
|
|
|
|
private let canOwnUserInviteCallsCountLock = NSLock()
|
|
private var canOwnUserInviteUnderlyingCallsCount = 0
|
|
open var canOwnUserInviteCallsCount: Int {
|
|
get { canOwnUserInviteCallsCountLock.withLock { canOwnUserInviteUnderlyingCallsCount } }
|
|
set { canOwnUserInviteCallsCountLock.withLock { canOwnUserInviteUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var canOwnUserInviteCalled: Bool {
|
|
return canOwnUserInviteCallsCount > 0
|
|
}
|
|
|
|
private let canOwnUserInviteReturnValueLock = NSLock()
|
|
open var canOwnUserInviteUnderlyingReturnValue: Bool!
|
|
open var canOwnUserInviteReturnValue: Bool! {
|
|
get { canOwnUserInviteReturnValueLock.withLock { canOwnUserInviteUnderlyingReturnValue } }
|
|
set { canOwnUserInviteReturnValueLock.withLock { canOwnUserInviteUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var canOwnUserInviteClosure: (() -> Bool)?
|
|
|
|
open override func canOwnUserInvite() -> Bool {
|
|
canOwnUserInviteCallsCountLock.withLock { canOwnUserInviteUnderlyingCallsCount += 1 }
|
|
if let canOwnUserInviteClosure = canOwnUserInviteClosure {
|
|
return canOwnUserInviteClosure()
|
|
} else {
|
|
return canOwnUserInviteReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - canOwnUserKick
|
|
|
|
private let canOwnUserKickCallsCountLock = NSLock()
|
|
private var canOwnUserKickUnderlyingCallsCount = 0
|
|
open var canOwnUserKickCallsCount: Int {
|
|
get { canOwnUserKickCallsCountLock.withLock { canOwnUserKickUnderlyingCallsCount } }
|
|
set { canOwnUserKickCallsCountLock.withLock { canOwnUserKickUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var canOwnUserKickCalled: Bool {
|
|
return canOwnUserKickCallsCount > 0
|
|
}
|
|
|
|
private let canOwnUserKickReturnValueLock = NSLock()
|
|
open var canOwnUserKickUnderlyingReturnValue: Bool!
|
|
open var canOwnUserKickReturnValue: Bool! {
|
|
get { canOwnUserKickReturnValueLock.withLock { canOwnUserKickUnderlyingReturnValue } }
|
|
set { canOwnUserKickReturnValueLock.withLock { canOwnUserKickUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var canOwnUserKickClosure: (() -> Bool)?
|
|
|
|
open override func canOwnUserKick() -> Bool {
|
|
canOwnUserKickCallsCountLock.withLock { canOwnUserKickUnderlyingCallsCount += 1 }
|
|
if let canOwnUserKickClosure = canOwnUserKickClosure {
|
|
return canOwnUserKickClosure()
|
|
} else {
|
|
return canOwnUserKickReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - canOwnUserPinUnpin
|
|
|
|
private let canOwnUserPinUnpinCallsCountLock = NSLock()
|
|
private var canOwnUserPinUnpinUnderlyingCallsCount = 0
|
|
open var canOwnUserPinUnpinCallsCount: Int {
|
|
get { canOwnUserPinUnpinCallsCountLock.withLock { canOwnUserPinUnpinUnderlyingCallsCount } }
|
|
set { canOwnUserPinUnpinCallsCountLock.withLock { canOwnUserPinUnpinUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var canOwnUserPinUnpinCalled: Bool {
|
|
return canOwnUserPinUnpinCallsCount > 0
|
|
}
|
|
|
|
private let canOwnUserPinUnpinReturnValueLock = NSLock()
|
|
open var canOwnUserPinUnpinUnderlyingReturnValue: Bool!
|
|
open var canOwnUserPinUnpinReturnValue: Bool! {
|
|
get { canOwnUserPinUnpinReturnValueLock.withLock { canOwnUserPinUnpinUnderlyingReturnValue } }
|
|
set { canOwnUserPinUnpinReturnValueLock.withLock { canOwnUserPinUnpinUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var canOwnUserPinUnpinClosure: (() -> Bool)?
|
|
|
|
open override func canOwnUserPinUnpin() -> Bool {
|
|
canOwnUserPinUnpinCallsCountLock.withLock { canOwnUserPinUnpinUnderlyingCallsCount += 1 }
|
|
if let canOwnUserPinUnpinClosure = canOwnUserPinUnpinClosure {
|
|
return canOwnUserPinUnpinClosure()
|
|
} else {
|
|
return canOwnUserPinUnpinReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - canOwnUserRedactOther
|
|
|
|
private let canOwnUserRedactOtherCallsCountLock = NSLock()
|
|
private var canOwnUserRedactOtherUnderlyingCallsCount = 0
|
|
open var canOwnUserRedactOtherCallsCount: Int {
|
|
get { canOwnUserRedactOtherCallsCountLock.withLock { canOwnUserRedactOtherUnderlyingCallsCount } }
|
|
set { canOwnUserRedactOtherCallsCountLock.withLock { canOwnUserRedactOtherUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var canOwnUserRedactOtherCalled: Bool {
|
|
return canOwnUserRedactOtherCallsCount > 0
|
|
}
|
|
|
|
private let canOwnUserRedactOtherReturnValueLock = NSLock()
|
|
open var canOwnUserRedactOtherUnderlyingReturnValue: Bool!
|
|
open var canOwnUserRedactOtherReturnValue: Bool! {
|
|
get { canOwnUserRedactOtherReturnValueLock.withLock { canOwnUserRedactOtherUnderlyingReturnValue } }
|
|
set { canOwnUserRedactOtherReturnValueLock.withLock { canOwnUserRedactOtherUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var canOwnUserRedactOtherClosure: (() -> Bool)?
|
|
|
|
open override func canOwnUserRedactOther() -> Bool {
|
|
canOwnUserRedactOtherCallsCountLock.withLock { canOwnUserRedactOtherUnderlyingCallsCount += 1 }
|
|
if let canOwnUserRedactOtherClosure = canOwnUserRedactOtherClosure {
|
|
return canOwnUserRedactOtherClosure()
|
|
} else {
|
|
return canOwnUserRedactOtherReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - canOwnUserRedactOwn
|
|
|
|
private let canOwnUserRedactOwnCallsCountLock = NSLock()
|
|
private var canOwnUserRedactOwnUnderlyingCallsCount = 0
|
|
open var canOwnUserRedactOwnCallsCount: Int {
|
|
get { canOwnUserRedactOwnCallsCountLock.withLock { canOwnUserRedactOwnUnderlyingCallsCount } }
|
|
set { canOwnUserRedactOwnCallsCountLock.withLock { canOwnUserRedactOwnUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var canOwnUserRedactOwnCalled: Bool {
|
|
return canOwnUserRedactOwnCallsCount > 0
|
|
}
|
|
|
|
private let canOwnUserRedactOwnReturnValueLock = NSLock()
|
|
open var canOwnUserRedactOwnUnderlyingReturnValue: Bool!
|
|
open var canOwnUserRedactOwnReturnValue: Bool! {
|
|
get { canOwnUserRedactOwnReturnValueLock.withLock { canOwnUserRedactOwnUnderlyingReturnValue } }
|
|
set { canOwnUserRedactOwnReturnValueLock.withLock { canOwnUserRedactOwnUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var canOwnUserRedactOwnClosure: (() -> Bool)?
|
|
|
|
open override func canOwnUserRedactOwn() -> Bool {
|
|
canOwnUserRedactOwnCallsCountLock.withLock { canOwnUserRedactOwnUnderlyingCallsCount += 1 }
|
|
if let canOwnUserRedactOwnClosure = canOwnUserRedactOwnClosure {
|
|
return canOwnUserRedactOwnClosure()
|
|
} else {
|
|
return canOwnUserRedactOwnReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - canOwnUserSendMessage
|
|
|
|
private let canOwnUserSendMessageMessageCallsCountLock = NSLock()
|
|
private var canOwnUserSendMessageMessageUnderlyingCallsCount = 0
|
|
open var canOwnUserSendMessageMessageCallsCount: Int {
|
|
get { canOwnUserSendMessageMessageCallsCountLock.withLock { canOwnUserSendMessageMessageUnderlyingCallsCount } }
|
|
set { canOwnUserSendMessageMessageCallsCountLock.withLock { canOwnUserSendMessageMessageUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var canOwnUserSendMessageMessageCalled: Bool {
|
|
return canOwnUserSendMessageMessageCallsCount > 0
|
|
}
|
|
private let canOwnUserSendMessageMessageReceivedMessageLock = NSLock()
|
|
private var canOwnUserSendMessageMessageUnderlyingReceivedMessage: MessageLikeEventType?
|
|
open var canOwnUserSendMessageMessageReceivedMessage: MessageLikeEventType? {
|
|
get { canOwnUserSendMessageMessageReceivedMessageLock.withLock { canOwnUserSendMessageMessageUnderlyingReceivedMessage } }
|
|
set { canOwnUserSendMessageMessageReceivedMessageLock.withLock { canOwnUserSendMessageMessageUnderlyingReceivedMessage = newValue } }
|
|
}
|
|
private let canOwnUserSendMessageMessageReceivedInvocationsLock = NSLock()
|
|
private var canOwnUserSendMessageMessageUnderlyingReceivedInvocations: [MessageLikeEventType] = []
|
|
open var canOwnUserSendMessageMessageReceivedInvocations: [MessageLikeEventType] {
|
|
get { canOwnUserSendMessageMessageReceivedInvocationsLock.withLock { canOwnUserSendMessageMessageUnderlyingReceivedInvocations } }
|
|
set { canOwnUserSendMessageMessageReceivedInvocationsLock.withLock { canOwnUserSendMessageMessageUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let canOwnUserSendMessageMessageReturnValueLock = NSLock()
|
|
open var canOwnUserSendMessageMessageUnderlyingReturnValue: Bool!
|
|
open var canOwnUserSendMessageMessageReturnValue: Bool! {
|
|
get { canOwnUserSendMessageMessageReturnValueLock.withLock { canOwnUserSendMessageMessageUnderlyingReturnValue } }
|
|
set { canOwnUserSendMessageMessageReturnValueLock.withLock { canOwnUserSendMessageMessageUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var canOwnUserSendMessageMessageClosure: ((MessageLikeEventType) -> Bool)?
|
|
|
|
open override func canOwnUserSendMessage(message: MessageLikeEventType) -> Bool {
|
|
canOwnUserSendMessageMessageCallsCountLock.withLock { canOwnUserSendMessageMessageUnderlyingCallsCount += 1 }
|
|
canOwnUserSendMessageMessageReceivedMessage = message
|
|
canOwnUserSendMessageMessageReceivedInvocationsLock.withLock { canOwnUserSendMessageMessageUnderlyingReceivedInvocations.append(message) }
|
|
if let canOwnUserSendMessageMessageClosure = canOwnUserSendMessageMessageClosure {
|
|
return canOwnUserSendMessageMessageClosure(message)
|
|
} else {
|
|
return canOwnUserSendMessageMessageReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - canOwnUserSendState
|
|
|
|
private let canOwnUserSendStateStateEventCallsCountLock = NSLock()
|
|
private var canOwnUserSendStateStateEventUnderlyingCallsCount = 0
|
|
open var canOwnUserSendStateStateEventCallsCount: Int {
|
|
get { canOwnUserSendStateStateEventCallsCountLock.withLock { canOwnUserSendStateStateEventUnderlyingCallsCount } }
|
|
set { canOwnUserSendStateStateEventCallsCountLock.withLock { canOwnUserSendStateStateEventUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var canOwnUserSendStateStateEventCalled: Bool {
|
|
return canOwnUserSendStateStateEventCallsCount > 0
|
|
}
|
|
private let canOwnUserSendStateStateEventReceivedStateEventLock = NSLock()
|
|
private var canOwnUserSendStateStateEventUnderlyingReceivedStateEvent: StateEventType?
|
|
open var canOwnUserSendStateStateEventReceivedStateEvent: StateEventType? {
|
|
get { canOwnUserSendStateStateEventReceivedStateEventLock.withLock { canOwnUserSendStateStateEventUnderlyingReceivedStateEvent } }
|
|
set { canOwnUserSendStateStateEventReceivedStateEventLock.withLock { canOwnUserSendStateStateEventUnderlyingReceivedStateEvent = newValue } }
|
|
}
|
|
private let canOwnUserSendStateStateEventReceivedInvocationsLock = NSLock()
|
|
private var canOwnUserSendStateStateEventUnderlyingReceivedInvocations: [StateEventType] = []
|
|
open var canOwnUserSendStateStateEventReceivedInvocations: [StateEventType] {
|
|
get { canOwnUserSendStateStateEventReceivedInvocationsLock.withLock { canOwnUserSendStateStateEventUnderlyingReceivedInvocations } }
|
|
set { canOwnUserSendStateStateEventReceivedInvocationsLock.withLock { canOwnUserSendStateStateEventUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let canOwnUserSendStateStateEventReturnValueLock = NSLock()
|
|
open var canOwnUserSendStateStateEventUnderlyingReturnValue: Bool!
|
|
open var canOwnUserSendStateStateEventReturnValue: Bool! {
|
|
get { canOwnUserSendStateStateEventReturnValueLock.withLock { canOwnUserSendStateStateEventUnderlyingReturnValue } }
|
|
set { canOwnUserSendStateStateEventReturnValueLock.withLock { canOwnUserSendStateStateEventUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var canOwnUserSendStateStateEventClosure: ((StateEventType) -> Bool)?
|
|
|
|
open override func canOwnUserSendState(stateEvent: StateEventType) -> Bool {
|
|
canOwnUserSendStateStateEventCallsCountLock.withLock { canOwnUserSendStateStateEventUnderlyingCallsCount += 1 }
|
|
canOwnUserSendStateStateEventReceivedStateEvent = stateEvent
|
|
canOwnUserSendStateStateEventReceivedInvocationsLock.withLock { canOwnUserSendStateStateEventUnderlyingReceivedInvocations.append(stateEvent) }
|
|
if let canOwnUserSendStateStateEventClosure = canOwnUserSendStateStateEventClosure {
|
|
return canOwnUserSendStateStateEventClosure(stateEvent)
|
|
} else {
|
|
return canOwnUserSendStateStateEventReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - canOwnUserTriggerRoomNotification
|
|
|
|
private let canOwnUserTriggerRoomNotificationCallsCountLock = NSLock()
|
|
private var canOwnUserTriggerRoomNotificationUnderlyingCallsCount = 0
|
|
open var canOwnUserTriggerRoomNotificationCallsCount: Int {
|
|
get { canOwnUserTriggerRoomNotificationCallsCountLock.withLock { canOwnUserTriggerRoomNotificationUnderlyingCallsCount } }
|
|
set { canOwnUserTriggerRoomNotificationCallsCountLock.withLock { canOwnUserTriggerRoomNotificationUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var canOwnUserTriggerRoomNotificationCalled: Bool {
|
|
return canOwnUserTriggerRoomNotificationCallsCount > 0
|
|
}
|
|
|
|
private let canOwnUserTriggerRoomNotificationReturnValueLock = NSLock()
|
|
open var canOwnUserTriggerRoomNotificationUnderlyingReturnValue: Bool!
|
|
open var canOwnUserTriggerRoomNotificationReturnValue: Bool! {
|
|
get { canOwnUserTriggerRoomNotificationReturnValueLock.withLock { canOwnUserTriggerRoomNotificationUnderlyingReturnValue } }
|
|
set { canOwnUserTriggerRoomNotificationReturnValueLock.withLock { canOwnUserTriggerRoomNotificationUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var canOwnUserTriggerRoomNotificationClosure: (() -> Bool)?
|
|
|
|
open override func canOwnUserTriggerRoomNotification() -> Bool {
|
|
canOwnUserTriggerRoomNotificationCallsCountLock.withLock { canOwnUserTriggerRoomNotificationUnderlyingCallsCount += 1 }
|
|
if let canOwnUserTriggerRoomNotificationClosure = canOwnUserTriggerRoomNotificationClosure {
|
|
return canOwnUserTriggerRoomNotificationClosure()
|
|
} else {
|
|
return canOwnUserTriggerRoomNotificationReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - canUserBan
|
|
|
|
open var canUserBanUserIdThrowableError: Error?
|
|
private let canUserBanUserIdCallsCountLock = NSLock()
|
|
private var canUserBanUserIdUnderlyingCallsCount = 0
|
|
open var canUserBanUserIdCallsCount: Int {
|
|
get { canUserBanUserIdCallsCountLock.withLock { canUserBanUserIdUnderlyingCallsCount } }
|
|
set { canUserBanUserIdCallsCountLock.withLock { canUserBanUserIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var canUserBanUserIdCalled: Bool {
|
|
return canUserBanUserIdCallsCount > 0
|
|
}
|
|
private let canUserBanUserIdReceivedUserIdLock = NSLock()
|
|
private var canUserBanUserIdUnderlyingReceivedUserId: String?
|
|
open var canUserBanUserIdReceivedUserId: String? {
|
|
get { canUserBanUserIdReceivedUserIdLock.withLock { canUserBanUserIdUnderlyingReceivedUserId } }
|
|
set { canUserBanUserIdReceivedUserIdLock.withLock { canUserBanUserIdUnderlyingReceivedUserId = newValue } }
|
|
}
|
|
private let canUserBanUserIdReceivedInvocationsLock = NSLock()
|
|
private var canUserBanUserIdUnderlyingReceivedInvocations: [String] = []
|
|
open var canUserBanUserIdReceivedInvocations: [String] {
|
|
get { canUserBanUserIdReceivedInvocationsLock.withLock { canUserBanUserIdUnderlyingReceivedInvocations } }
|
|
set { canUserBanUserIdReceivedInvocationsLock.withLock { canUserBanUserIdUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let canUserBanUserIdReturnValueLock = NSLock()
|
|
open var canUserBanUserIdUnderlyingReturnValue: Bool!
|
|
open var canUserBanUserIdReturnValue: Bool! {
|
|
get { canUserBanUserIdReturnValueLock.withLock { canUserBanUserIdUnderlyingReturnValue } }
|
|
set { canUserBanUserIdReturnValueLock.withLock { canUserBanUserIdUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var canUserBanUserIdClosure: ((String) throws -> Bool)?
|
|
|
|
open override func canUserBan(userId: String) throws -> Bool {
|
|
if let error = canUserBanUserIdThrowableError {
|
|
throw error
|
|
}
|
|
canUserBanUserIdCallsCountLock.withLock { canUserBanUserIdUnderlyingCallsCount += 1 }
|
|
canUserBanUserIdReceivedUserId = userId
|
|
canUserBanUserIdReceivedInvocationsLock.withLock { canUserBanUserIdUnderlyingReceivedInvocations.append(userId) }
|
|
if let canUserBanUserIdClosure = canUserBanUserIdClosure {
|
|
return try canUserBanUserIdClosure(userId)
|
|
} else {
|
|
return canUserBanUserIdReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - canUserInvite
|
|
|
|
open var canUserInviteUserIdThrowableError: Error?
|
|
private let canUserInviteUserIdCallsCountLock = NSLock()
|
|
private var canUserInviteUserIdUnderlyingCallsCount = 0
|
|
open var canUserInviteUserIdCallsCount: Int {
|
|
get { canUserInviteUserIdCallsCountLock.withLock { canUserInviteUserIdUnderlyingCallsCount } }
|
|
set { canUserInviteUserIdCallsCountLock.withLock { canUserInviteUserIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var canUserInviteUserIdCalled: Bool {
|
|
return canUserInviteUserIdCallsCount > 0
|
|
}
|
|
private let canUserInviteUserIdReceivedUserIdLock = NSLock()
|
|
private var canUserInviteUserIdUnderlyingReceivedUserId: String?
|
|
open var canUserInviteUserIdReceivedUserId: String? {
|
|
get { canUserInviteUserIdReceivedUserIdLock.withLock { canUserInviteUserIdUnderlyingReceivedUserId } }
|
|
set { canUserInviteUserIdReceivedUserIdLock.withLock { canUserInviteUserIdUnderlyingReceivedUserId = newValue } }
|
|
}
|
|
private let canUserInviteUserIdReceivedInvocationsLock = NSLock()
|
|
private var canUserInviteUserIdUnderlyingReceivedInvocations: [String] = []
|
|
open var canUserInviteUserIdReceivedInvocations: [String] {
|
|
get { canUserInviteUserIdReceivedInvocationsLock.withLock { canUserInviteUserIdUnderlyingReceivedInvocations } }
|
|
set { canUserInviteUserIdReceivedInvocationsLock.withLock { canUserInviteUserIdUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let canUserInviteUserIdReturnValueLock = NSLock()
|
|
open var canUserInviteUserIdUnderlyingReturnValue: Bool!
|
|
open var canUserInviteUserIdReturnValue: Bool! {
|
|
get { canUserInviteUserIdReturnValueLock.withLock { canUserInviteUserIdUnderlyingReturnValue } }
|
|
set { canUserInviteUserIdReturnValueLock.withLock { canUserInviteUserIdUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var canUserInviteUserIdClosure: ((String) throws -> Bool)?
|
|
|
|
open override func canUserInvite(userId: String) throws -> Bool {
|
|
if let error = canUserInviteUserIdThrowableError {
|
|
throw error
|
|
}
|
|
canUserInviteUserIdCallsCountLock.withLock { canUserInviteUserIdUnderlyingCallsCount += 1 }
|
|
canUserInviteUserIdReceivedUserId = userId
|
|
canUserInviteUserIdReceivedInvocationsLock.withLock { canUserInviteUserIdUnderlyingReceivedInvocations.append(userId) }
|
|
if let canUserInviteUserIdClosure = canUserInviteUserIdClosure {
|
|
return try canUserInviteUserIdClosure(userId)
|
|
} else {
|
|
return canUserInviteUserIdReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - canUserKick
|
|
|
|
open var canUserKickUserIdThrowableError: Error?
|
|
private let canUserKickUserIdCallsCountLock = NSLock()
|
|
private var canUserKickUserIdUnderlyingCallsCount = 0
|
|
open var canUserKickUserIdCallsCount: Int {
|
|
get { canUserKickUserIdCallsCountLock.withLock { canUserKickUserIdUnderlyingCallsCount } }
|
|
set { canUserKickUserIdCallsCountLock.withLock { canUserKickUserIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var canUserKickUserIdCalled: Bool {
|
|
return canUserKickUserIdCallsCount > 0
|
|
}
|
|
private let canUserKickUserIdReceivedUserIdLock = NSLock()
|
|
private var canUserKickUserIdUnderlyingReceivedUserId: String?
|
|
open var canUserKickUserIdReceivedUserId: String? {
|
|
get { canUserKickUserIdReceivedUserIdLock.withLock { canUserKickUserIdUnderlyingReceivedUserId } }
|
|
set { canUserKickUserIdReceivedUserIdLock.withLock { canUserKickUserIdUnderlyingReceivedUserId = newValue } }
|
|
}
|
|
private let canUserKickUserIdReceivedInvocationsLock = NSLock()
|
|
private var canUserKickUserIdUnderlyingReceivedInvocations: [String] = []
|
|
open var canUserKickUserIdReceivedInvocations: [String] {
|
|
get { canUserKickUserIdReceivedInvocationsLock.withLock { canUserKickUserIdUnderlyingReceivedInvocations } }
|
|
set { canUserKickUserIdReceivedInvocationsLock.withLock { canUserKickUserIdUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let canUserKickUserIdReturnValueLock = NSLock()
|
|
open var canUserKickUserIdUnderlyingReturnValue: Bool!
|
|
open var canUserKickUserIdReturnValue: Bool! {
|
|
get { canUserKickUserIdReturnValueLock.withLock { canUserKickUserIdUnderlyingReturnValue } }
|
|
set { canUserKickUserIdReturnValueLock.withLock { canUserKickUserIdUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var canUserKickUserIdClosure: ((String) throws -> Bool)?
|
|
|
|
open override func canUserKick(userId: String) throws -> Bool {
|
|
if let error = canUserKickUserIdThrowableError {
|
|
throw error
|
|
}
|
|
canUserKickUserIdCallsCountLock.withLock { canUserKickUserIdUnderlyingCallsCount += 1 }
|
|
canUserKickUserIdReceivedUserId = userId
|
|
canUserKickUserIdReceivedInvocationsLock.withLock { canUserKickUserIdUnderlyingReceivedInvocations.append(userId) }
|
|
if let canUserKickUserIdClosure = canUserKickUserIdClosure {
|
|
return try canUserKickUserIdClosure(userId)
|
|
} else {
|
|
return canUserKickUserIdReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - canUserPinUnpin
|
|
|
|
open var canUserPinUnpinUserIdThrowableError: Error?
|
|
private let canUserPinUnpinUserIdCallsCountLock = NSLock()
|
|
private var canUserPinUnpinUserIdUnderlyingCallsCount = 0
|
|
open var canUserPinUnpinUserIdCallsCount: Int {
|
|
get { canUserPinUnpinUserIdCallsCountLock.withLock { canUserPinUnpinUserIdUnderlyingCallsCount } }
|
|
set { canUserPinUnpinUserIdCallsCountLock.withLock { canUserPinUnpinUserIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var canUserPinUnpinUserIdCalled: Bool {
|
|
return canUserPinUnpinUserIdCallsCount > 0
|
|
}
|
|
private let canUserPinUnpinUserIdReceivedUserIdLock = NSLock()
|
|
private var canUserPinUnpinUserIdUnderlyingReceivedUserId: String?
|
|
open var canUserPinUnpinUserIdReceivedUserId: String? {
|
|
get { canUserPinUnpinUserIdReceivedUserIdLock.withLock { canUserPinUnpinUserIdUnderlyingReceivedUserId } }
|
|
set { canUserPinUnpinUserIdReceivedUserIdLock.withLock { canUserPinUnpinUserIdUnderlyingReceivedUserId = newValue } }
|
|
}
|
|
private let canUserPinUnpinUserIdReceivedInvocationsLock = NSLock()
|
|
private var canUserPinUnpinUserIdUnderlyingReceivedInvocations: [String] = []
|
|
open var canUserPinUnpinUserIdReceivedInvocations: [String] {
|
|
get { canUserPinUnpinUserIdReceivedInvocationsLock.withLock { canUserPinUnpinUserIdUnderlyingReceivedInvocations } }
|
|
set { canUserPinUnpinUserIdReceivedInvocationsLock.withLock { canUserPinUnpinUserIdUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let canUserPinUnpinUserIdReturnValueLock = NSLock()
|
|
open var canUserPinUnpinUserIdUnderlyingReturnValue: Bool!
|
|
open var canUserPinUnpinUserIdReturnValue: Bool! {
|
|
get { canUserPinUnpinUserIdReturnValueLock.withLock { canUserPinUnpinUserIdUnderlyingReturnValue } }
|
|
set { canUserPinUnpinUserIdReturnValueLock.withLock { canUserPinUnpinUserIdUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var canUserPinUnpinUserIdClosure: ((String) throws -> Bool)?
|
|
|
|
open override func canUserPinUnpin(userId: String) throws -> Bool {
|
|
if let error = canUserPinUnpinUserIdThrowableError {
|
|
throw error
|
|
}
|
|
canUserPinUnpinUserIdCallsCountLock.withLock { canUserPinUnpinUserIdUnderlyingCallsCount += 1 }
|
|
canUserPinUnpinUserIdReceivedUserId = userId
|
|
canUserPinUnpinUserIdReceivedInvocationsLock.withLock { canUserPinUnpinUserIdUnderlyingReceivedInvocations.append(userId) }
|
|
if let canUserPinUnpinUserIdClosure = canUserPinUnpinUserIdClosure {
|
|
return try canUserPinUnpinUserIdClosure(userId)
|
|
} else {
|
|
return canUserPinUnpinUserIdReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - canUserRedactOther
|
|
|
|
open var canUserRedactOtherUserIdThrowableError: Error?
|
|
private let canUserRedactOtherUserIdCallsCountLock = NSLock()
|
|
private var canUserRedactOtherUserIdUnderlyingCallsCount = 0
|
|
open var canUserRedactOtherUserIdCallsCount: Int {
|
|
get { canUserRedactOtherUserIdCallsCountLock.withLock { canUserRedactOtherUserIdUnderlyingCallsCount } }
|
|
set { canUserRedactOtherUserIdCallsCountLock.withLock { canUserRedactOtherUserIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var canUserRedactOtherUserIdCalled: Bool {
|
|
return canUserRedactOtherUserIdCallsCount > 0
|
|
}
|
|
private let canUserRedactOtherUserIdReceivedUserIdLock = NSLock()
|
|
private var canUserRedactOtherUserIdUnderlyingReceivedUserId: String?
|
|
open var canUserRedactOtherUserIdReceivedUserId: String? {
|
|
get { canUserRedactOtherUserIdReceivedUserIdLock.withLock { canUserRedactOtherUserIdUnderlyingReceivedUserId } }
|
|
set { canUserRedactOtherUserIdReceivedUserIdLock.withLock { canUserRedactOtherUserIdUnderlyingReceivedUserId = newValue } }
|
|
}
|
|
private let canUserRedactOtherUserIdReceivedInvocationsLock = NSLock()
|
|
private var canUserRedactOtherUserIdUnderlyingReceivedInvocations: [String] = []
|
|
open var canUserRedactOtherUserIdReceivedInvocations: [String] {
|
|
get { canUserRedactOtherUserIdReceivedInvocationsLock.withLock { canUserRedactOtherUserIdUnderlyingReceivedInvocations } }
|
|
set { canUserRedactOtherUserIdReceivedInvocationsLock.withLock { canUserRedactOtherUserIdUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let canUserRedactOtherUserIdReturnValueLock = NSLock()
|
|
open var canUserRedactOtherUserIdUnderlyingReturnValue: Bool!
|
|
open var canUserRedactOtherUserIdReturnValue: Bool! {
|
|
get { canUserRedactOtherUserIdReturnValueLock.withLock { canUserRedactOtherUserIdUnderlyingReturnValue } }
|
|
set { canUserRedactOtherUserIdReturnValueLock.withLock { canUserRedactOtherUserIdUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var canUserRedactOtherUserIdClosure: ((String) throws -> Bool)?
|
|
|
|
open override func canUserRedactOther(userId: String) throws -> Bool {
|
|
if let error = canUserRedactOtherUserIdThrowableError {
|
|
throw error
|
|
}
|
|
canUserRedactOtherUserIdCallsCountLock.withLock { canUserRedactOtherUserIdUnderlyingCallsCount += 1 }
|
|
canUserRedactOtherUserIdReceivedUserId = userId
|
|
canUserRedactOtherUserIdReceivedInvocationsLock.withLock { canUserRedactOtherUserIdUnderlyingReceivedInvocations.append(userId) }
|
|
if let canUserRedactOtherUserIdClosure = canUserRedactOtherUserIdClosure {
|
|
return try canUserRedactOtherUserIdClosure(userId)
|
|
} else {
|
|
return canUserRedactOtherUserIdReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - canUserRedactOwn
|
|
|
|
open var canUserRedactOwnUserIdThrowableError: Error?
|
|
private let canUserRedactOwnUserIdCallsCountLock = NSLock()
|
|
private var canUserRedactOwnUserIdUnderlyingCallsCount = 0
|
|
open var canUserRedactOwnUserIdCallsCount: Int {
|
|
get { canUserRedactOwnUserIdCallsCountLock.withLock { canUserRedactOwnUserIdUnderlyingCallsCount } }
|
|
set { canUserRedactOwnUserIdCallsCountLock.withLock { canUserRedactOwnUserIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var canUserRedactOwnUserIdCalled: Bool {
|
|
return canUserRedactOwnUserIdCallsCount > 0
|
|
}
|
|
private let canUserRedactOwnUserIdReceivedUserIdLock = NSLock()
|
|
private var canUserRedactOwnUserIdUnderlyingReceivedUserId: String?
|
|
open var canUserRedactOwnUserIdReceivedUserId: String? {
|
|
get { canUserRedactOwnUserIdReceivedUserIdLock.withLock { canUserRedactOwnUserIdUnderlyingReceivedUserId } }
|
|
set { canUserRedactOwnUserIdReceivedUserIdLock.withLock { canUserRedactOwnUserIdUnderlyingReceivedUserId = newValue } }
|
|
}
|
|
private let canUserRedactOwnUserIdReceivedInvocationsLock = NSLock()
|
|
private var canUserRedactOwnUserIdUnderlyingReceivedInvocations: [String] = []
|
|
open var canUserRedactOwnUserIdReceivedInvocations: [String] {
|
|
get { canUserRedactOwnUserIdReceivedInvocationsLock.withLock { canUserRedactOwnUserIdUnderlyingReceivedInvocations } }
|
|
set { canUserRedactOwnUserIdReceivedInvocationsLock.withLock { canUserRedactOwnUserIdUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let canUserRedactOwnUserIdReturnValueLock = NSLock()
|
|
open var canUserRedactOwnUserIdUnderlyingReturnValue: Bool!
|
|
open var canUserRedactOwnUserIdReturnValue: Bool! {
|
|
get { canUserRedactOwnUserIdReturnValueLock.withLock { canUserRedactOwnUserIdUnderlyingReturnValue } }
|
|
set { canUserRedactOwnUserIdReturnValueLock.withLock { canUserRedactOwnUserIdUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var canUserRedactOwnUserIdClosure: ((String) throws -> Bool)?
|
|
|
|
open override func canUserRedactOwn(userId: String) throws -> Bool {
|
|
if let error = canUserRedactOwnUserIdThrowableError {
|
|
throw error
|
|
}
|
|
canUserRedactOwnUserIdCallsCountLock.withLock { canUserRedactOwnUserIdUnderlyingCallsCount += 1 }
|
|
canUserRedactOwnUserIdReceivedUserId = userId
|
|
canUserRedactOwnUserIdReceivedInvocationsLock.withLock { canUserRedactOwnUserIdUnderlyingReceivedInvocations.append(userId) }
|
|
if let canUserRedactOwnUserIdClosure = canUserRedactOwnUserIdClosure {
|
|
return try canUserRedactOwnUserIdClosure(userId)
|
|
} else {
|
|
return canUserRedactOwnUserIdReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - canUserSendMessage
|
|
|
|
open var canUserSendMessageUserIdMessageThrowableError: Error?
|
|
private let canUserSendMessageUserIdMessageCallsCountLock = NSLock()
|
|
private var canUserSendMessageUserIdMessageUnderlyingCallsCount = 0
|
|
open var canUserSendMessageUserIdMessageCallsCount: Int {
|
|
get { canUserSendMessageUserIdMessageCallsCountLock.withLock { canUserSendMessageUserIdMessageUnderlyingCallsCount } }
|
|
set { canUserSendMessageUserIdMessageCallsCountLock.withLock { canUserSendMessageUserIdMessageUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var canUserSendMessageUserIdMessageCalled: Bool {
|
|
return canUserSendMessageUserIdMessageCallsCount > 0
|
|
}
|
|
private let canUserSendMessageUserIdMessageReceivedArgumentsLock = NSLock()
|
|
private var canUserSendMessageUserIdMessageUnderlyingReceivedArguments: (userId: String, message: MessageLikeEventType)?
|
|
open var canUserSendMessageUserIdMessageReceivedArguments: (userId: String, message: MessageLikeEventType)? {
|
|
get { canUserSendMessageUserIdMessageReceivedArgumentsLock.withLock { canUserSendMessageUserIdMessageUnderlyingReceivedArguments } }
|
|
set { canUserSendMessageUserIdMessageReceivedArgumentsLock.withLock { canUserSendMessageUserIdMessageUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let canUserSendMessageUserIdMessageReceivedInvocationsLock = NSLock()
|
|
private var canUserSendMessageUserIdMessageUnderlyingReceivedInvocations: [(userId: String, message: MessageLikeEventType)] = []
|
|
open var canUserSendMessageUserIdMessageReceivedInvocations: [(userId: String, message: MessageLikeEventType)] {
|
|
get { canUserSendMessageUserIdMessageReceivedInvocationsLock.withLock { canUserSendMessageUserIdMessageUnderlyingReceivedInvocations } }
|
|
set { canUserSendMessageUserIdMessageReceivedInvocationsLock.withLock { canUserSendMessageUserIdMessageUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let canUserSendMessageUserIdMessageReturnValueLock = NSLock()
|
|
open var canUserSendMessageUserIdMessageUnderlyingReturnValue: Bool!
|
|
open var canUserSendMessageUserIdMessageReturnValue: Bool! {
|
|
get { canUserSendMessageUserIdMessageReturnValueLock.withLock { canUserSendMessageUserIdMessageUnderlyingReturnValue } }
|
|
set { canUserSendMessageUserIdMessageReturnValueLock.withLock { canUserSendMessageUserIdMessageUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var canUserSendMessageUserIdMessageClosure: ((String, MessageLikeEventType) throws -> Bool)?
|
|
|
|
open override func canUserSendMessage(userId: String, message: MessageLikeEventType) throws -> Bool {
|
|
if let error = canUserSendMessageUserIdMessageThrowableError {
|
|
throw error
|
|
}
|
|
canUserSendMessageUserIdMessageCallsCountLock.withLock { canUserSendMessageUserIdMessageUnderlyingCallsCount += 1 }
|
|
canUserSendMessageUserIdMessageReceivedArguments = (userId: userId, message: message)
|
|
canUserSendMessageUserIdMessageReceivedInvocationsLock.withLock { canUserSendMessageUserIdMessageUnderlyingReceivedInvocations.append((userId: userId, message: message)) }
|
|
if let canUserSendMessageUserIdMessageClosure = canUserSendMessageUserIdMessageClosure {
|
|
return try canUserSendMessageUserIdMessageClosure(userId, message)
|
|
} else {
|
|
return canUserSendMessageUserIdMessageReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - canUserSendState
|
|
|
|
open var canUserSendStateUserIdStateEventThrowableError: Error?
|
|
private let canUserSendStateUserIdStateEventCallsCountLock = NSLock()
|
|
private var canUserSendStateUserIdStateEventUnderlyingCallsCount = 0
|
|
open var canUserSendStateUserIdStateEventCallsCount: Int {
|
|
get { canUserSendStateUserIdStateEventCallsCountLock.withLock { canUserSendStateUserIdStateEventUnderlyingCallsCount } }
|
|
set { canUserSendStateUserIdStateEventCallsCountLock.withLock { canUserSendStateUserIdStateEventUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var canUserSendStateUserIdStateEventCalled: Bool {
|
|
return canUserSendStateUserIdStateEventCallsCount > 0
|
|
}
|
|
private let canUserSendStateUserIdStateEventReceivedArgumentsLock = NSLock()
|
|
private var canUserSendStateUserIdStateEventUnderlyingReceivedArguments: (userId: String, stateEvent: StateEventType)?
|
|
open var canUserSendStateUserIdStateEventReceivedArguments: (userId: String, stateEvent: StateEventType)? {
|
|
get { canUserSendStateUserIdStateEventReceivedArgumentsLock.withLock { canUserSendStateUserIdStateEventUnderlyingReceivedArguments } }
|
|
set { canUserSendStateUserIdStateEventReceivedArgumentsLock.withLock { canUserSendStateUserIdStateEventUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let canUserSendStateUserIdStateEventReceivedInvocationsLock = NSLock()
|
|
private var canUserSendStateUserIdStateEventUnderlyingReceivedInvocations: [(userId: String, stateEvent: StateEventType)] = []
|
|
open var canUserSendStateUserIdStateEventReceivedInvocations: [(userId: String, stateEvent: StateEventType)] {
|
|
get { canUserSendStateUserIdStateEventReceivedInvocationsLock.withLock { canUserSendStateUserIdStateEventUnderlyingReceivedInvocations } }
|
|
set { canUserSendStateUserIdStateEventReceivedInvocationsLock.withLock { canUserSendStateUserIdStateEventUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let canUserSendStateUserIdStateEventReturnValueLock = NSLock()
|
|
open var canUserSendStateUserIdStateEventUnderlyingReturnValue: Bool!
|
|
open var canUserSendStateUserIdStateEventReturnValue: Bool! {
|
|
get { canUserSendStateUserIdStateEventReturnValueLock.withLock { canUserSendStateUserIdStateEventUnderlyingReturnValue } }
|
|
set { canUserSendStateUserIdStateEventReturnValueLock.withLock { canUserSendStateUserIdStateEventUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var canUserSendStateUserIdStateEventClosure: ((String, StateEventType) throws -> Bool)?
|
|
|
|
open override func canUserSendState(userId: String, stateEvent: StateEventType) throws -> Bool {
|
|
if let error = canUserSendStateUserIdStateEventThrowableError {
|
|
throw error
|
|
}
|
|
canUserSendStateUserIdStateEventCallsCountLock.withLock { canUserSendStateUserIdStateEventUnderlyingCallsCount += 1 }
|
|
canUserSendStateUserIdStateEventReceivedArguments = (userId: userId, stateEvent: stateEvent)
|
|
canUserSendStateUserIdStateEventReceivedInvocationsLock.withLock { canUserSendStateUserIdStateEventUnderlyingReceivedInvocations.append((userId: userId, stateEvent: stateEvent)) }
|
|
if let canUserSendStateUserIdStateEventClosure = canUserSendStateUserIdStateEventClosure {
|
|
return try canUserSendStateUserIdStateEventClosure(userId, stateEvent)
|
|
} else {
|
|
return canUserSendStateUserIdStateEventReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - canUserTriggerRoomNotification
|
|
|
|
open var canUserTriggerRoomNotificationUserIdThrowableError: Error?
|
|
private let canUserTriggerRoomNotificationUserIdCallsCountLock = NSLock()
|
|
private var canUserTriggerRoomNotificationUserIdUnderlyingCallsCount = 0
|
|
open var canUserTriggerRoomNotificationUserIdCallsCount: Int {
|
|
get { canUserTriggerRoomNotificationUserIdCallsCountLock.withLock { canUserTriggerRoomNotificationUserIdUnderlyingCallsCount } }
|
|
set { canUserTriggerRoomNotificationUserIdCallsCountLock.withLock { canUserTriggerRoomNotificationUserIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var canUserTriggerRoomNotificationUserIdCalled: Bool {
|
|
return canUserTriggerRoomNotificationUserIdCallsCount > 0
|
|
}
|
|
private let canUserTriggerRoomNotificationUserIdReceivedUserIdLock = NSLock()
|
|
private var canUserTriggerRoomNotificationUserIdUnderlyingReceivedUserId: String?
|
|
open var canUserTriggerRoomNotificationUserIdReceivedUserId: String? {
|
|
get { canUserTriggerRoomNotificationUserIdReceivedUserIdLock.withLock { canUserTriggerRoomNotificationUserIdUnderlyingReceivedUserId } }
|
|
set { canUserTriggerRoomNotificationUserIdReceivedUserIdLock.withLock { canUserTriggerRoomNotificationUserIdUnderlyingReceivedUserId = newValue } }
|
|
}
|
|
private let canUserTriggerRoomNotificationUserIdReceivedInvocationsLock = NSLock()
|
|
private var canUserTriggerRoomNotificationUserIdUnderlyingReceivedInvocations: [String] = []
|
|
open var canUserTriggerRoomNotificationUserIdReceivedInvocations: [String] {
|
|
get { canUserTriggerRoomNotificationUserIdReceivedInvocationsLock.withLock { canUserTriggerRoomNotificationUserIdUnderlyingReceivedInvocations } }
|
|
set { canUserTriggerRoomNotificationUserIdReceivedInvocationsLock.withLock { canUserTriggerRoomNotificationUserIdUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let canUserTriggerRoomNotificationUserIdReturnValueLock = NSLock()
|
|
open var canUserTriggerRoomNotificationUserIdUnderlyingReturnValue: Bool!
|
|
open var canUserTriggerRoomNotificationUserIdReturnValue: Bool! {
|
|
get { canUserTriggerRoomNotificationUserIdReturnValueLock.withLock { canUserTriggerRoomNotificationUserIdUnderlyingReturnValue } }
|
|
set { canUserTriggerRoomNotificationUserIdReturnValueLock.withLock { canUserTriggerRoomNotificationUserIdUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var canUserTriggerRoomNotificationUserIdClosure: ((String) throws -> Bool)?
|
|
|
|
open override func canUserTriggerRoomNotification(userId: String) throws -> Bool {
|
|
if let error = canUserTriggerRoomNotificationUserIdThrowableError {
|
|
throw error
|
|
}
|
|
canUserTriggerRoomNotificationUserIdCallsCountLock.withLock { canUserTriggerRoomNotificationUserIdUnderlyingCallsCount += 1 }
|
|
canUserTriggerRoomNotificationUserIdReceivedUserId = userId
|
|
canUserTriggerRoomNotificationUserIdReceivedInvocationsLock.withLock { canUserTriggerRoomNotificationUserIdUnderlyingReceivedInvocations.append(userId) }
|
|
if let canUserTriggerRoomNotificationUserIdClosure = canUserTriggerRoomNotificationUserIdClosure {
|
|
return try canUserTriggerRoomNotificationUserIdClosure(userId)
|
|
} else {
|
|
return canUserTriggerRoomNotificationUserIdReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - events
|
|
|
|
private let eventsCallsCountLock = NSLock()
|
|
private var eventsUnderlyingCallsCount = 0
|
|
open var eventsCallsCount: Int {
|
|
get { eventsCallsCountLock.withLock { eventsUnderlyingCallsCount } }
|
|
set { eventsCallsCountLock.withLock { eventsUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var eventsCalled: Bool {
|
|
return eventsCallsCount > 0
|
|
}
|
|
|
|
private let eventsReturnValueLock = NSLock()
|
|
open var eventsUnderlyingReturnValue: [FfiTimelineEventType: Int64]!
|
|
open var eventsReturnValue: [FfiTimelineEventType: Int64]! {
|
|
get { eventsReturnValueLock.withLock { eventsUnderlyingReturnValue } }
|
|
set { eventsReturnValueLock.withLock { eventsUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var eventsClosure: (() -> [FfiTimelineEventType: Int64])?
|
|
|
|
open override func events() -> [FfiTimelineEventType: Int64] {
|
|
eventsCallsCountLock.withLock { eventsUnderlyingCallsCount += 1 }
|
|
if let eventsClosure = eventsClosure {
|
|
return eventsClosure()
|
|
} else {
|
|
return eventsReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - userPowerLevels
|
|
|
|
private let userPowerLevelsCallsCountLock = NSLock()
|
|
private var userPowerLevelsUnderlyingCallsCount = 0
|
|
open var userPowerLevelsCallsCount: Int {
|
|
get { userPowerLevelsCallsCountLock.withLock { userPowerLevelsUnderlyingCallsCount } }
|
|
set { userPowerLevelsCallsCountLock.withLock { userPowerLevelsUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var userPowerLevelsCalled: Bool {
|
|
return userPowerLevelsCallsCount > 0
|
|
}
|
|
|
|
private let userPowerLevelsReturnValueLock = NSLock()
|
|
open var userPowerLevelsUnderlyingReturnValue: [String: Int64]!
|
|
open var userPowerLevelsReturnValue: [String: Int64]! {
|
|
get { userPowerLevelsReturnValueLock.withLock { userPowerLevelsUnderlyingReturnValue } }
|
|
set { userPowerLevelsReturnValueLock.withLock { userPowerLevelsUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var userPowerLevelsClosure: (() -> [String: Int64])?
|
|
|
|
open override func userPowerLevels() -> [String: Int64] {
|
|
userPowerLevelsCallsCountLock.withLock { userPowerLevelsUnderlyingCallsCount += 1 }
|
|
if let userPowerLevelsClosure = userPowerLevelsClosure {
|
|
return userPowerLevelsClosure()
|
|
} else {
|
|
return userPowerLevelsReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - values
|
|
|
|
private let valuesCallsCountLock = NSLock()
|
|
private var valuesUnderlyingCallsCount = 0
|
|
open var valuesCallsCount: Int {
|
|
get { valuesCallsCountLock.withLock { valuesUnderlyingCallsCount } }
|
|
set { valuesCallsCountLock.withLock { valuesUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var valuesCalled: Bool {
|
|
return valuesCallsCount > 0
|
|
}
|
|
|
|
private let valuesReturnValueLock = NSLock()
|
|
open var valuesUnderlyingReturnValue: RoomPowerLevelsValues!
|
|
open var valuesReturnValue: RoomPowerLevelsValues! {
|
|
get { valuesReturnValueLock.withLock { valuesUnderlyingReturnValue } }
|
|
set { valuesReturnValueLock.withLock { valuesUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var valuesClosure: (() -> RoomPowerLevelsValues)?
|
|
|
|
open override func values() -> RoomPowerLevelsValues {
|
|
valuesCallsCountLock.withLock { valuesUnderlyingCallsCount += 1 }
|
|
if let valuesClosure = valuesClosure {
|
|
return valuesClosure()
|
|
} else {
|
|
return valuesReturnValue
|
|
}
|
|
}
|
|
}
|
|
open class RoomPreviewSDKMock: MatrixRustSDK.RoomPreview, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
|
|
//MARK: - forget
|
|
|
|
open var forgetThrowableError: Error?
|
|
private let forgetCallsCountLock = NSLock()
|
|
private var forgetUnderlyingCallsCount = 0
|
|
open var forgetCallsCount: Int {
|
|
get { forgetCallsCountLock.withLock { forgetUnderlyingCallsCount } }
|
|
set { forgetCallsCountLock.withLock { forgetUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var forgetCalled: Bool {
|
|
return forgetCallsCount > 0
|
|
}
|
|
open var forgetClosure: (() async throws -> Void)?
|
|
|
|
open override func forget() async throws {
|
|
if let error = forgetThrowableError {
|
|
throw error
|
|
}
|
|
forgetCallsCountLock.withLock { forgetUnderlyingCallsCount += 1 }
|
|
try await forgetClosure?()
|
|
}
|
|
|
|
//MARK: - info
|
|
|
|
private let infoCallsCountLock = NSLock()
|
|
private var infoUnderlyingCallsCount = 0
|
|
open var infoCallsCount: Int {
|
|
get { infoCallsCountLock.withLock { infoUnderlyingCallsCount } }
|
|
set { infoCallsCountLock.withLock { infoUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var infoCalled: Bool {
|
|
return infoCallsCount > 0
|
|
}
|
|
|
|
private let infoReturnValueLock = NSLock()
|
|
open var infoUnderlyingReturnValue: RoomPreviewInfo!
|
|
open var infoReturnValue: RoomPreviewInfo! {
|
|
get { infoReturnValueLock.withLock { infoUnderlyingReturnValue } }
|
|
set { infoReturnValueLock.withLock { infoUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var infoClosure: (() -> RoomPreviewInfo)?
|
|
|
|
open override func info() -> RoomPreviewInfo {
|
|
infoCallsCountLock.withLock { infoUnderlyingCallsCount += 1 }
|
|
if let infoClosure = infoClosure {
|
|
return infoClosure()
|
|
} else {
|
|
return infoReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - inviter
|
|
|
|
private let inviterCallsCountLock = NSLock()
|
|
private var inviterUnderlyingCallsCount = 0
|
|
open var inviterCallsCount: Int {
|
|
get { inviterCallsCountLock.withLock { inviterUnderlyingCallsCount } }
|
|
set { inviterCallsCountLock.withLock { inviterUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var inviterCalled: Bool {
|
|
return inviterCallsCount > 0
|
|
}
|
|
|
|
private let inviterReturnValueLock = NSLock()
|
|
open var inviterUnderlyingReturnValue: RoomMember?
|
|
open var inviterReturnValue: RoomMember? {
|
|
get { inviterReturnValueLock.withLock { inviterUnderlyingReturnValue } }
|
|
set { inviterReturnValueLock.withLock { inviterUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var inviterClosure: (() async -> RoomMember?)?
|
|
|
|
open override func inviter() async -> RoomMember? {
|
|
inviterCallsCountLock.withLock { inviterUnderlyingCallsCount += 1 }
|
|
if let inviterClosure = inviterClosure {
|
|
return await inviterClosure()
|
|
} else {
|
|
return inviterReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - leave
|
|
|
|
open var leaveThrowableError: Error?
|
|
private let leaveCallsCountLock = NSLock()
|
|
private var leaveUnderlyingCallsCount = 0
|
|
open var leaveCallsCount: Int {
|
|
get { leaveCallsCountLock.withLock { leaveUnderlyingCallsCount } }
|
|
set { leaveCallsCountLock.withLock { leaveUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var leaveCalled: Bool {
|
|
return leaveCallsCount > 0
|
|
}
|
|
open var leaveClosure: (() async throws -> Void)?
|
|
|
|
open override func leave() async throws {
|
|
if let error = leaveThrowableError {
|
|
throw error
|
|
}
|
|
leaveCallsCountLock.withLock { leaveUnderlyingCallsCount += 1 }
|
|
try await leaveClosure?()
|
|
}
|
|
|
|
//MARK: - ownMembershipDetails
|
|
|
|
private let ownMembershipDetailsCallsCountLock = NSLock()
|
|
private var ownMembershipDetailsUnderlyingCallsCount = 0
|
|
open var ownMembershipDetailsCallsCount: Int {
|
|
get { ownMembershipDetailsCallsCountLock.withLock { ownMembershipDetailsUnderlyingCallsCount } }
|
|
set { ownMembershipDetailsCallsCountLock.withLock { ownMembershipDetailsUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var ownMembershipDetailsCalled: Bool {
|
|
return ownMembershipDetailsCallsCount > 0
|
|
}
|
|
|
|
private let ownMembershipDetailsReturnValueLock = NSLock()
|
|
open var ownMembershipDetailsUnderlyingReturnValue: RoomMemberWithSenderInfo?
|
|
open var ownMembershipDetailsReturnValue: RoomMemberWithSenderInfo? {
|
|
get { ownMembershipDetailsReturnValueLock.withLock { ownMembershipDetailsUnderlyingReturnValue } }
|
|
set { ownMembershipDetailsReturnValueLock.withLock { ownMembershipDetailsUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var ownMembershipDetailsClosure: (() async -> RoomMemberWithSenderInfo?)?
|
|
|
|
open override func ownMembershipDetails() async -> RoomMemberWithSenderInfo? {
|
|
ownMembershipDetailsCallsCountLock.withLock { ownMembershipDetailsUnderlyingCallsCount += 1 }
|
|
if let ownMembershipDetailsClosure = ownMembershipDetailsClosure {
|
|
return await ownMembershipDetailsClosure()
|
|
} else {
|
|
return ownMembershipDetailsReturnValue
|
|
}
|
|
}
|
|
}
|
|
open class SearchServiceSDKMock: MatrixRustSDK.SearchService, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
|
|
//MARK: - paginate
|
|
|
|
open var paginateThrowableError: Error?
|
|
private let paginateCallsCountLock = NSLock()
|
|
private var paginateUnderlyingCallsCount = 0
|
|
open var paginateCallsCount: Int {
|
|
get { paginateCallsCountLock.withLock { paginateUnderlyingCallsCount } }
|
|
set { paginateCallsCountLock.withLock { paginateUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var paginateCalled: Bool {
|
|
return paginateCallsCount > 0
|
|
}
|
|
open var paginateClosure: (() async throws -> Void)?
|
|
|
|
open override func paginate() async throws {
|
|
if let error = paginateThrowableError {
|
|
throw error
|
|
}
|
|
paginateCallsCountLock.withLock { paginateUnderlyingCallsCount += 1 }
|
|
try await paginateClosure?()
|
|
}
|
|
|
|
//MARK: - paginationState
|
|
|
|
private let paginationStateCallsCountLock = NSLock()
|
|
private var paginationStateUnderlyingCallsCount = 0
|
|
open var paginationStateCallsCount: Int {
|
|
get { paginationStateCallsCountLock.withLock { paginationStateUnderlyingCallsCount } }
|
|
set { paginationStateCallsCountLock.withLock { paginationStateUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var paginationStateCalled: Bool {
|
|
return paginationStateCallsCount > 0
|
|
}
|
|
|
|
private let paginationStateReturnValueLock = NSLock()
|
|
open var paginationStateUnderlyingReturnValue: SearchServicePaginationState!
|
|
open var paginationStateReturnValue: SearchServicePaginationState! {
|
|
get { paginationStateReturnValueLock.withLock { paginationStateUnderlyingReturnValue } }
|
|
set { paginationStateReturnValueLock.withLock { paginationStateUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var paginationStateClosure: (() -> SearchServicePaginationState)?
|
|
|
|
open override func paginationState() -> SearchServicePaginationState {
|
|
paginationStateCallsCountLock.withLock { paginationStateUnderlyingCallsCount += 1 }
|
|
if let paginationStateClosure = paginationStateClosure {
|
|
return paginationStateClosure()
|
|
} else {
|
|
return paginationStateReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - setQuery
|
|
|
|
open var setQueryQueryThrowableError: Error?
|
|
private let setQueryQueryCallsCountLock = NSLock()
|
|
private var setQueryQueryUnderlyingCallsCount = 0
|
|
open var setQueryQueryCallsCount: Int {
|
|
get { setQueryQueryCallsCountLock.withLock { setQueryQueryUnderlyingCallsCount } }
|
|
set { setQueryQueryCallsCountLock.withLock { setQueryQueryUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var setQueryQueryCalled: Bool {
|
|
return setQueryQueryCallsCount > 0
|
|
}
|
|
private let setQueryQueryReceivedQueryLock = NSLock()
|
|
private var setQueryQueryUnderlyingReceivedQuery: String?
|
|
open var setQueryQueryReceivedQuery: String? {
|
|
get { setQueryQueryReceivedQueryLock.withLock { setQueryQueryUnderlyingReceivedQuery } }
|
|
set { setQueryQueryReceivedQueryLock.withLock { setQueryQueryUnderlyingReceivedQuery = newValue } }
|
|
}
|
|
private let setQueryQueryReceivedInvocationsLock = NSLock()
|
|
private var setQueryQueryUnderlyingReceivedInvocations: [String] = []
|
|
open var setQueryQueryReceivedInvocations: [String] {
|
|
get { setQueryQueryReceivedInvocationsLock.withLock { setQueryQueryUnderlyingReceivedInvocations } }
|
|
set { setQueryQueryReceivedInvocationsLock.withLock { setQueryQueryUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var setQueryQueryClosure: ((String) async throws -> Void)?
|
|
|
|
open override func setQuery(query: String) async throws {
|
|
if let error = setQueryQueryThrowableError {
|
|
throw error
|
|
}
|
|
setQueryQueryCallsCountLock.withLock { setQueryQueryUnderlyingCallsCount += 1 }
|
|
setQueryQueryReceivedQuery = query
|
|
setQueryQueryReceivedInvocationsLock.withLock { setQueryQueryUnderlyingReceivedInvocations.append(query) }
|
|
try await setQueryQueryClosure?(query)
|
|
}
|
|
|
|
//MARK: - subscribeToPaginationStateUpdates
|
|
|
|
private let subscribeToPaginationStateUpdatesListenerCallsCountLock = NSLock()
|
|
private var subscribeToPaginationStateUpdatesListenerUnderlyingCallsCount = 0
|
|
open var subscribeToPaginationStateUpdatesListenerCallsCount: Int {
|
|
get { subscribeToPaginationStateUpdatesListenerCallsCountLock.withLock { subscribeToPaginationStateUpdatesListenerUnderlyingCallsCount } }
|
|
set { subscribeToPaginationStateUpdatesListenerCallsCountLock.withLock { subscribeToPaginationStateUpdatesListenerUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var subscribeToPaginationStateUpdatesListenerCalled: Bool {
|
|
return subscribeToPaginationStateUpdatesListenerCallsCount > 0
|
|
}
|
|
private let subscribeToPaginationStateUpdatesListenerReceivedListenerLock = NSLock()
|
|
private var subscribeToPaginationStateUpdatesListenerUnderlyingReceivedListener: SearchServicePaginationStateListener?
|
|
open var subscribeToPaginationStateUpdatesListenerReceivedListener: SearchServicePaginationStateListener? {
|
|
get { subscribeToPaginationStateUpdatesListenerReceivedListenerLock.withLock { subscribeToPaginationStateUpdatesListenerUnderlyingReceivedListener } }
|
|
set { subscribeToPaginationStateUpdatesListenerReceivedListenerLock.withLock { subscribeToPaginationStateUpdatesListenerUnderlyingReceivedListener = newValue } }
|
|
}
|
|
private let subscribeToPaginationStateUpdatesListenerReceivedInvocationsLock = NSLock()
|
|
private var subscribeToPaginationStateUpdatesListenerUnderlyingReceivedInvocations: [SearchServicePaginationStateListener] = []
|
|
open var subscribeToPaginationStateUpdatesListenerReceivedInvocations: [SearchServicePaginationStateListener] {
|
|
get { subscribeToPaginationStateUpdatesListenerReceivedInvocationsLock.withLock { subscribeToPaginationStateUpdatesListenerUnderlyingReceivedInvocations } }
|
|
set { subscribeToPaginationStateUpdatesListenerReceivedInvocationsLock.withLock { subscribeToPaginationStateUpdatesListenerUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let subscribeToPaginationStateUpdatesListenerReturnValueLock = NSLock()
|
|
open var subscribeToPaginationStateUpdatesListenerUnderlyingReturnValue: TaskHandle!
|
|
open var subscribeToPaginationStateUpdatesListenerReturnValue: TaskHandle! {
|
|
get { subscribeToPaginationStateUpdatesListenerReturnValueLock.withLock { subscribeToPaginationStateUpdatesListenerUnderlyingReturnValue } }
|
|
set { subscribeToPaginationStateUpdatesListenerReturnValueLock.withLock { subscribeToPaginationStateUpdatesListenerUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var subscribeToPaginationStateUpdatesListenerClosure: ((SearchServicePaginationStateListener) -> TaskHandle)?
|
|
|
|
open override func subscribeToPaginationStateUpdates(listener: SearchServicePaginationStateListener) -> TaskHandle {
|
|
subscribeToPaginationStateUpdatesListenerCallsCountLock.withLock { subscribeToPaginationStateUpdatesListenerUnderlyingCallsCount += 1 }
|
|
subscribeToPaginationStateUpdatesListenerReceivedListener = listener
|
|
subscribeToPaginationStateUpdatesListenerReceivedInvocationsLock.withLock { subscribeToPaginationStateUpdatesListenerUnderlyingReceivedInvocations.append(listener) }
|
|
if let subscribeToPaginationStateUpdatesListenerClosure = subscribeToPaginationStateUpdatesListenerClosure {
|
|
return subscribeToPaginationStateUpdatesListenerClosure(listener)
|
|
} else {
|
|
return subscribeToPaginationStateUpdatesListenerReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - subscribeToResults
|
|
|
|
private let subscribeToResultsListenerCallsCountLock = NSLock()
|
|
private var subscribeToResultsListenerUnderlyingCallsCount = 0
|
|
open var subscribeToResultsListenerCallsCount: Int {
|
|
get { subscribeToResultsListenerCallsCountLock.withLock { subscribeToResultsListenerUnderlyingCallsCount } }
|
|
set { subscribeToResultsListenerCallsCountLock.withLock { subscribeToResultsListenerUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var subscribeToResultsListenerCalled: Bool {
|
|
return subscribeToResultsListenerCallsCount > 0
|
|
}
|
|
private let subscribeToResultsListenerReceivedListenerLock = NSLock()
|
|
private var subscribeToResultsListenerUnderlyingReceivedListener: SearchServiceResultsListener?
|
|
open var subscribeToResultsListenerReceivedListener: SearchServiceResultsListener? {
|
|
get { subscribeToResultsListenerReceivedListenerLock.withLock { subscribeToResultsListenerUnderlyingReceivedListener } }
|
|
set { subscribeToResultsListenerReceivedListenerLock.withLock { subscribeToResultsListenerUnderlyingReceivedListener = newValue } }
|
|
}
|
|
private let subscribeToResultsListenerReceivedInvocationsLock = NSLock()
|
|
private var subscribeToResultsListenerUnderlyingReceivedInvocations: [SearchServiceResultsListener] = []
|
|
open var subscribeToResultsListenerReceivedInvocations: [SearchServiceResultsListener] {
|
|
get { subscribeToResultsListenerReceivedInvocationsLock.withLock { subscribeToResultsListenerUnderlyingReceivedInvocations } }
|
|
set { subscribeToResultsListenerReceivedInvocationsLock.withLock { subscribeToResultsListenerUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let subscribeToResultsListenerReturnValueLock = NSLock()
|
|
open var subscribeToResultsListenerUnderlyingReturnValue: TaskHandle!
|
|
open var subscribeToResultsListenerReturnValue: TaskHandle! {
|
|
get { subscribeToResultsListenerReturnValueLock.withLock { subscribeToResultsListenerUnderlyingReturnValue } }
|
|
set { subscribeToResultsListenerReturnValueLock.withLock { subscribeToResultsListenerUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var subscribeToResultsListenerClosure: ((SearchServiceResultsListener) async -> TaskHandle)?
|
|
|
|
open override func subscribeToResults(listener: SearchServiceResultsListener) async -> TaskHandle {
|
|
subscribeToResultsListenerCallsCountLock.withLock { subscribeToResultsListenerUnderlyingCallsCount += 1 }
|
|
subscribeToResultsListenerReceivedListener = listener
|
|
subscribeToResultsListenerReceivedInvocationsLock.withLock { subscribeToResultsListenerUnderlyingReceivedInvocations.append(listener) }
|
|
if let subscribeToResultsListenerClosure = subscribeToResultsListenerClosure {
|
|
return await subscribeToResultsListenerClosure(listener)
|
|
} else {
|
|
return subscribeToResultsListenerReturnValue
|
|
}
|
|
}
|
|
}
|
|
open class SecretsBundleSDKMock: MatrixRustSDK.SecretsBundle, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
}
|
|
open class SecretsBundleWithUserIdSDKMock: MatrixRustSDK.SecretsBundleWithUserId, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
static func reset()
|
|
{
|
|
}
|
|
|
|
//MARK: - containsBackupKey
|
|
|
|
private let containsBackupKeyCallsCountLock = NSLock()
|
|
private var containsBackupKeyUnderlyingCallsCount = 0
|
|
open var containsBackupKeyCallsCount: Int {
|
|
get { containsBackupKeyCallsCountLock.withLock { containsBackupKeyUnderlyingCallsCount } }
|
|
set { containsBackupKeyCallsCountLock.withLock { containsBackupKeyUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var containsBackupKeyCalled: Bool {
|
|
return containsBackupKeyCallsCount > 0
|
|
}
|
|
|
|
private let containsBackupKeyReturnValueLock = NSLock()
|
|
open var containsBackupKeyUnderlyingReturnValue: Bool!
|
|
open var containsBackupKeyReturnValue: Bool! {
|
|
get { containsBackupKeyReturnValueLock.withLock { containsBackupKeyUnderlyingReturnValue } }
|
|
set { containsBackupKeyReturnValueLock.withLock { containsBackupKeyUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var containsBackupKeyClosure: (() -> Bool)?
|
|
|
|
open override func containsBackupKey() -> Bool {
|
|
containsBackupKeyCallsCountLock.withLock { containsBackupKeyUnderlyingCallsCount += 1 }
|
|
if let containsBackupKeyClosure = containsBackupKeyClosure {
|
|
return containsBackupKeyClosure()
|
|
} else {
|
|
return containsBackupKeyReturnValue
|
|
}
|
|
}
|
|
}
|
|
open class SendAttachmentJoinHandleSDKMock: MatrixRustSDK.SendAttachmentJoinHandle, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
|
|
//MARK: - cancel
|
|
|
|
private let cancelCallsCountLock = NSLock()
|
|
private var cancelUnderlyingCallsCount = 0
|
|
open var cancelCallsCount: Int {
|
|
get { cancelCallsCountLock.withLock { cancelUnderlyingCallsCount } }
|
|
set { cancelCallsCountLock.withLock { cancelUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var cancelCalled: Bool {
|
|
return cancelCallsCount > 0
|
|
}
|
|
open var cancelClosure: (() -> Void)?
|
|
|
|
open override func cancel() {
|
|
cancelCallsCountLock.withLock { cancelUnderlyingCallsCount += 1 }
|
|
cancelClosure?()
|
|
}
|
|
|
|
//MARK: - join
|
|
|
|
open var joinThrowableError: Error?
|
|
private let joinCallsCountLock = NSLock()
|
|
private var joinUnderlyingCallsCount = 0
|
|
open var joinCallsCount: Int {
|
|
get { joinCallsCountLock.withLock { joinUnderlyingCallsCount } }
|
|
set { joinCallsCountLock.withLock { joinUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var joinCalled: Bool {
|
|
return joinCallsCount > 0
|
|
}
|
|
open var joinClosure: (() async throws -> Void)?
|
|
|
|
open override func join() async throws {
|
|
if let error = joinThrowableError {
|
|
throw error
|
|
}
|
|
joinCallsCountLock.withLock { joinUnderlyingCallsCount += 1 }
|
|
try await joinClosure?()
|
|
}
|
|
}
|
|
open class SendGalleryJoinHandleSDKMock: MatrixRustSDK.SendGalleryJoinHandle, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
|
|
//MARK: - cancel
|
|
|
|
private let cancelCallsCountLock = NSLock()
|
|
private var cancelUnderlyingCallsCount = 0
|
|
open var cancelCallsCount: Int {
|
|
get { cancelCallsCountLock.withLock { cancelUnderlyingCallsCount } }
|
|
set { cancelCallsCountLock.withLock { cancelUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var cancelCalled: Bool {
|
|
return cancelCallsCount > 0
|
|
}
|
|
open var cancelClosure: (() -> Void)?
|
|
|
|
open override func cancel() {
|
|
cancelCallsCountLock.withLock { cancelUnderlyingCallsCount += 1 }
|
|
cancelClosure?()
|
|
}
|
|
|
|
//MARK: - join
|
|
|
|
open var joinThrowableError: Error?
|
|
private let joinCallsCountLock = NSLock()
|
|
private var joinUnderlyingCallsCount = 0
|
|
open var joinCallsCount: Int {
|
|
get { joinCallsCountLock.withLock { joinUnderlyingCallsCount } }
|
|
set { joinCallsCountLock.withLock { joinUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var joinCalled: Bool {
|
|
return joinCallsCount > 0
|
|
}
|
|
open var joinClosure: (() async throws -> Void)?
|
|
|
|
open override func join() async throws {
|
|
if let error = joinThrowableError {
|
|
throw error
|
|
}
|
|
joinCallsCountLock.withLock { joinUnderlyingCallsCount += 1 }
|
|
try await joinClosure?()
|
|
}
|
|
}
|
|
open class SendHandleSDKMock: MatrixRustSDK.SendHandle, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
|
|
//MARK: - abort
|
|
|
|
open var abortThrowableError: Error?
|
|
private let abortCallsCountLock = NSLock()
|
|
private var abortUnderlyingCallsCount = 0
|
|
open var abortCallsCount: Int {
|
|
get { abortCallsCountLock.withLock { abortUnderlyingCallsCount } }
|
|
set { abortCallsCountLock.withLock { abortUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var abortCalled: Bool {
|
|
return abortCallsCount > 0
|
|
}
|
|
|
|
private let abortReturnValueLock = NSLock()
|
|
open var abortUnderlyingReturnValue: Bool!
|
|
open var abortReturnValue: Bool! {
|
|
get { abortReturnValueLock.withLock { abortUnderlyingReturnValue } }
|
|
set { abortReturnValueLock.withLock { abortUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var abortClosure: (() async throws -> Bool)?
|
|
|
|
open override func abort() async throws -> Bool {
|
|
if let error = abortThrowableError {
|
|
throw error
|
|
}
|
|
abortCallsCountLock.withLock { abortUnderlyingCallsCount += 1 }
|
|
if let abortClosure = abortClosure {
|
|
return try await abortClosure()
|
|
} else {
|
|
return abortReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - tryResend
|
|
|
|
open var tryResendThrowableError: Error?
|
|
private let tryResendCallsCountLock = NSLock()
|
|
private var tryResendUnderlyingCallsCount = 0
|
|
open var tryResendCallsCount: Int {
|
|
get { tryResendCallsCountLock.withLock { tryResendUnderlyingCallsCount } }
|
|
set { tryResendCallsCountLock.withLock { tryResendUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var tryResendCalled: Bool {
|
|
return tryResendCallsCount > 0
|
|
}
|
|
open var tryResendClosure: (() async throws -> Void)?
|
|
|
|
open override func tryResend() async throws {
|
|
if let error = tryResendThrowableError {
|
|
throw error
|
|
}
|
|
tryResendCallsCountLock.withLock { tryResendUnderlyingCallsCount += 1 }
|
|
try await tryResendClosure?()
|
|
}
|
|
}
|
|
open class SessionVerificationControllerSDKMock: MatrixRustSDK.SessionVerificationController, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
|
|
//MARK: - acceptVerificationRequest
|
|
|
|
open var acceptVerificationRequestThrowableError: Error?
|
|
private let acceptVerificationRequestCallsCountLock = NSLock()
|
|
private var acceptVerificationRequestUnderlyingCallsCount = 0
|
|
open var acceptVerificationRequestCallsCount: Int {
|
|
get { acceptVerificationRequestCallsCountLock.withLock { acceptVerificationRequestUnderlyingCallsCount } }
|
|
set { acceptVerificationRequestCallsCountLock.withLock { acceptVerificationRequestUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var acceptVerificationRequestCalled: Bool {
|
|
return acceptVerificationRequestCallsCount > 0
|
|
}
|
|
open var acceptVerificationRequestClosure: (() async throws -> Void)?
|
|
|
|
open override func acceptVerificationRequest() async throws {
|
|
if let error = acceptVerificationRequestThrowableError {
|
|
throw error
|
|
}
|
|
acceptVerificationRequestCallsCountLock.withLock { acceptVerificationRequestUnderlyingCallsCount += 1 }
|
|
try await acceptVerificationRequestClosure?()
|
|
}
|
|
|
|
//MARK: - acknowledgeVerificationRequest
|
|
|
|
open var acknowledgeVerificationRequestSenderIdFlowIdThrowableError: Error?
|
|
private let acknowledgeVerificationRequestSenderIdFlowIdCallsCountLock = NSLock()
|
|
private var acknowledgeVerificationRequestSenderIdFlowIdUnderlyingCallsCount = 0
|
|
open var acknowledgeVerificationRequestSenderIdFlowIdCallsCount: Int {
|
|
get { acknowledgeVerificationRequestSenderIdFlowIdCallsCountLock.withLock { acknowledgeVerificationRequestSenderIdFlowIdUnderlyingCallsCount } }
|
|
set { acknowledgeVerificationRequestSenderIdFlowIdCallsCountLock.withLock { acknowledgeVerificationRequestSenderIdFlowIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var acknowledgeVerificationRequestSenderIdFlowIdCalled: Bool {
|
|
return acknowledgeVerificationRequestSenderIdFlowIdCallsCount > 0
|
|
}
|
|
private let acknowledgeVerificationRequestSenderIdFlowIdReceivedArgumentsLock = NSLock()
|
|
private var acknowledgeVerificationRequestSenderIdFlowIdUnderlyingReceivedArguments: (senderId: String, flowId: String)?
|
|
open var acknowledgeVerificationRequestSenderIdFlowIdReceivedArguments: (senderId: String, flowId: String)? {
|
|
get { acknowledgeVerificationRequestSenderIdFlowIdReceivedArgumentsLock.withLock { acknowledgeVerificationRequestSenderIdFlowIdUnderlyingReceivedArguments } }
|
|
set { acknowledgeVerificationRequestSenderIdFlowIdReceivedArgumentsLock.withLock { acknowledgeVerificationRequestSenderIdFlowIdUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let acknowledgeVerificationRequestSenderIdFlowIdReceivedInvocationsLock = NSLock()
|
|
private var acknowledgeVerificationRequestSenderIdFlowIdUnderlyingReceivedInvocations: [(senderId: String, flowId: String)] = []
|
|
open var acknowledgeVerificationRequestSenderIdFlowIdReceivedInvocations: [(senderId: String, flowId: String)] {
|
|
get { acknowledgeVerificationRequestSenderIdFlowIdReceivedInvocationsLock.withLock { acknowledgeVerificationRequestSenderIdFlowIdUnderlyingReceivedInvocations } }
|
|
set { acknowledgeVerificationRequestSenderIdFlowIdReceivedInvocationsLock.withLock { acknowledgeVerificationRequestSenderIdFlowIdUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var acknowledgeVerificationRequestSenderIdFlowIdClosure: ((String, String) async throws -> Void)?
|
|
|
|
open override func acknowledgeVerificationRequest(senderId: String, flowId: String) async throws {
|
|
if let error = acknowledgeVerificationRequestSenderIdFlowIdThrowableError {
|
|
throw error
|
|
}
|
|
acknowledgeVerificationRequestSenderIdFlowIdCallsCountLock.withLock { acknowledgeVerificationRequestSenderIdFlowIdUnderlyingCallsCount += 1 }
|
|
acknowledgeVerificationRequestSenderIdFlowIdReceivedArguments = (senderId: senderId, flowId: flowId)
|
|
acknowledgeVerificationRequestSenderIdFlowIdReceivedInvocationsLock.withLock { acknowledgeVerificationRequestSenderIdFlowIdUnderlyingReceivedInvocations.append((senderId: senderId, flowId: flowId)) }
|
|
try await acknowledgeVerificationRequestSenderIdFlowIdClosure?(senderId, flowId)
|
|
}
|
|
|
|
//MARK: - approveVerification
|
|
|
|
open var approveVerificationThrowableError: Error?
|
|
private let approveVerificationCallsCountLock = NSLock()
|
|
private var approveVerificationUnderlyingCallsCount = 0
|
|
open var approveVerificationCallsCount: Int {
|
|
get { approveVerificationCallsCountLock.withLock { approveVerificationUnderlyingCallsCount } }
|
|
set { approveVerificationCallsCountLock.withLock { approveVerificationUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var approveVerificationCalled: Bool {
|
|
return approveVerificationCallsCount > 0
|
|
}
|
|
open var approveVerificationClosure: (() async throws -> Void)?
|
|
|
|
open override func approveVerification() async throws {
|
|
if let error = approveVerificationThrowableError {
|
|
throw error
|
|
}
|
|
approveVerificationCallsCountLock.withLock { approveVerificationUnderlyingCallsCount += 1 }
|
|
try await approveVerificationClosure?()
|
|
}
|
|
|
|
//MARK: - cancelVerification
|
|
|
|
open var cancelVerificationThrowableError: Error?
|
|
private let cancelVerificationCallsCountLock = NSLock()
|
|
private var cancelVerificationUnderlyingCallsCount = 0
|
|
open var cancelVerificationCallsCount: Int {
|
|
get { cancelVerificationCallsCountLock.withLock { cancelVerificationUnderlyingCallsCount } }
|
|
set { cancelVerificationCallsCountLock.withLock { cancelVerificationUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var cancelVerificationCalled: Bool {
|
|
return cancelVerificationCallsCount > 0
|
|
}
|
|
open var cancelVerificationClosure: (() async throws -> Void)?
|
|
|
|
open override func cancelVerification() async throws {
|
|
if let error = cancelVerificationThrowableError {
|
|
throw error
|
|
}
|
|
cancelVerificationCallsCountLock.withLock { cancelVerificationUnderlyingCallsCount += 1 }
|
|
try await cancelVerificationClosure?()
|
|
}
|
|
|
|
//MARK: - declineVerification
|
|
|
|
open var declineVerificationThrowableError: Error?
|
|
private let declineVerificationCallsCountLock = NSLock()
|
|
private var declineVerificationUnderlyingCallsCount = 0
|
|
open var declineVerificationCallsCount: Int {
|
|
get { declineVerificationCallsCountLock.withLock { declineVerificationUnderlyingCallsCount } }
|
|
set { declineVerificationCallsCountLock.withLock { declineVerificationUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var declineVerificationCalled: Bool {
|
|
return declineVerificationCallsCount > 0
|
|
}
|
|
open var declineVerificationClosure: (() async throws -> Void)?
|
|
|
|
open override func declineVerification() async throws {
|
|
if let error = declineVerificationThrowableError {
|
|
throw error
|
|
}
|
|
declineVerificationCallsCountLock.withLock { declineVerificationUnderlyingCallsCount += 1 }
|
|
try await declineVerificationClosure?()
|
|
}
|
|
|
|
//MARK: - requestDeviceVerification
|
|
|
|
open var requestDeviceVerificationThrowableError: Error?
|
|
private let requestDeviceVerificationCallsCountLock = NSLock()
|
|
private var requestDeviceVerificationUnderlyingCallsCount = 0
|
|
open var requestDeviceVerificationCallsCount: Int {
|
|
get { requestDeviceVerificationCallsCountLock.withLock { requestDeviceVerificationUnderlyingCallsCount } }
|
|
set { requestDeviceVerificationCallsCountLock.withLock { requestDeviceVerificationUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var requestDeviceVerificationCalled: Bool {
|
|
return requestDeviceVerificationCallsCount > 0
|
|
}
|
|
open var requestDeviceVerificationClosure: (() async throws -> Void)?
|
|
|
|
open override func requestDeviceVerification() async throws {
|
|
if let error = requestDeviceVerificationThrowableError {
|
|
throw error
|
|
}
|
|
requestDeviceVerificationCallsCountLock.withLock { requestDeviceVerificationUnderlyingCallsCount += 1 }
|
|
try await requestDeviceVerificationClosure?()
|
|
}
|
|
|
|
//MARK: - requestUserVerification
|
|
|
|
open var requestUserVerificationUserIdThrowableError: Error?
|
|
private let requestUserVerificationUserIdCallsCountLock = NSLock()
|
|
private var requestUserVerificationUserIdUnderlyingCallsCount = 0
|
|
open var requestUserVerificationUserIdCallsCount: Int {
|
|
get { requestUserVerificationUserIdCallsCountLock.withLock { requestUserVerificationUserIdUnderlyingCallsCount } }
|
|
set { requestUserVerificationUserIdCallsCountLock.withLock { requestUserVerificationUserIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var requestUserVerificationUserIdCalled: Bool {
|
|
return requestUserVerificationUserIdCallsCount > 0
|
|
}
|
|
private let requestUserVerificationUserIdReceivedUserIdLock = NSLock()
|
|
private var requestUserVerificationUserIdUnderlyingReceivedUserId: String?
|
|
open var requestUserVerificationUserIdReceivedUserId: String? {
|
|
get { requestUserVerificationUserIdReceivedUserIdLock.withLock { requestUserVerificationUserIdUnderlyingReceivedUserId } }
|
|
set { requestUserVerificationUserIdReceivedUserIdLock.withLock { requestUserVerificationUserIdUnderlyingReceivedUserId = newValue } }
|
|
}
|
|
private let requestUserVerificationUserIdReceivedInvocationsLock = NSLock()
|
|
private var requestUserVerificationUserIdUnderlyingReceivedInvocations: [String] = []
|
|
open var requestUserVerificationUserIdReceivedInvocations: [String] {
|
|
get { requestUserVerificationUserIdReceivedInvocationsLock.withLock { requestUserVerificationUserIdUnderlyingReceivedInvocations } }
|
|
set { requestUserVerificationUserIdReceivedInvocationsLock.withLock { requestUserVerificationUserIdUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var requestUserVerificationUserIdClosure: ((String) async throws -> Void)?
|
|
|
|
open override func requestUserVerification(userId: String) async throws {
|
|
if let error = requestUserVerificationUserIdThrowableError {
|
|
throw error
|
|
}
|
|
requestUserVerificationUserIdCallsCountLock.withLock { requestUserVerificationUserIdUnderlyingCallsCount += 1 }
|
|
requestUserVerificationUserIdReceivedUserId = userId
|
|
requestUserVerificationUserIdReceivedInvocationsLock.withLock { requestUserVerificationUserIdUnderlyingReceivedInvocations.append(userId) }
|
|
try await requestUserVerificationUserIdClosure?(userId)
|
|
}
|
|
|
|
//MARK: - setDelegate
|
|
|
|
private let setDelegateDelegateCallsCountLock = NSLock()
|
|
private var setDelegateDelegateUnderlyingCallsCount = 0
|
|
open var setDelegateDelegateCallsCount: Int {
|
|
get { setDelegateDelegateCallsCountLock.withLock { setDelegateDelegateUnderlyingCallsCount } }
|
|
set { setDelegateDelegateCallsCountLock.withLock { setDelegateDelegateUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var setDelegateDelegateCalled: Bool {
|
|
return setDelegateDelegateCallsCount > 0
|
|
}
|
|
private let setDelegateDelegateReceivedDelegateLock = NSLock()
|
|
private var setDelegateDelegateUnderlyingReceivedDelegate: SessionVerificationControllerDelegate?
|
|
open var setDelegateDelegateReceivedDelegate: SessionVerificationControllerDelegate? {
|
|
get { setDelegateDelegateReceivedDelegateLock.withLock { setDelegateDelegateUnderlyingReceivedDelegate } }
|
|
set { setDelegateDelegateReceivedDelegateLock.withLock { setDelegateDelegateUnderlyingReceivedDelegate = newValue } }
|
|
}
|
|
private let setDelegateDelegateReceivedInvocationsLock = NSLock()
|
|
private var setDelegateDelegateUnderlyingReceivedInvocations: [SessionVerificationControllerDelegate?] = []
|
|
open var setDelegateDelegateReceivedInvocations: [SessionVerificationControllerDelegate?] {
|
|
get { setDelegateDelegateReceivedInvocationsLock.withLock { setDelegateDelegateUnderlyingReceivedInvocations } }
|
|
set { setDelegateDelegateReceivedInvocationsLock.withLock { setDelegateDelegateUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var setDelegateDelegateClosure: ((SessionVerificationControllerDelegate?) -> Void)?
|
|
|
|
open override func setDelegate(delegate: SessionVerificationControllerDelegate?) {
|
|
setDelegateDelegateCallsCountLock.withLock { setDelegateDelegateUnderlyingCallsCount += 1 }
|
|
setDelegateDelegateReceivedDelegate = delegate
|
|
setDelegateDelegateReceivedInvocationsLock.withLock { setDelegateDelegateUnderlyingReceivedInvocations.append(delegate) }
|
|
setDelegateDelegateClosure?(delegate)
|
|
}
|
|
|
|
//MARK: - startSasVerification
|
|
|
|
open var startSasVerificationThrowableError: Error?
|
|
private let startSasVerificationCallsCountLock = NSLock()
|
|
private var startSasVerificationUnderlyingCallsCount = 0
|
|
open var startSasVerificationCallsCount: Int {
|
|
get { startSasVerificationCallsCountLock.withLock { startSasVerificationUnderlyingCallsCount } }
|
|
set { startSasVerificationCallsCountLock.withLock { startSasVerificationUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var startSasVerificationCalled: Bool {
|
|
return startSasVerificationCallsCount > 0
|
|
}
|
|
open var startSasVerificationClosure: (() async throws -> Void)?
|
|
|
|
open override func startSasVerification() async throws {
|
|
if let error = startSasVerificationThrowableError {
|
|
throw error
|
|
}
|
|
startSasVerificationCallsCountLock.withLock { startSasVerificationUnderlyingCallsCount += 1 }
|
|
try await startSasVerificationClosure?()
|
|
}
|
|
}
|
|
open class SessionVerificationEmojiSDKMock: MatrixRustSDK.SessionVerificationEmoji, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
|
|
//MARK: - description
|
|
|
|
private let descriptionCallsCountLock = NSLock()
|
|
private var descriptionUnderlyingCallsCount = 0
|
|
open var descriptionCallsCount: Int {
|
|
get { descriptionCallsCountLock.withLock { descriptionUnderlyingCallsCount } }
|
|
set { descriptionCallsCountLock.withLock { descriptionUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var descriptionCalled: Bool {
|
|
return descriptionCallsCount > 0
|
|
}
|
|
|
|
private let descriptionReturnValueLock = NSLock()
|
|
open var descriptionUnderlyingReturnValue: String!
|
|
open var descriptionReturnValue: String! {
|
|
get { descriptionReturnValueLock.withLock { descriptionUnderlyingReturnValue } }
|
|
set { descriptionReturnValueLock.withLock { descriptionUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var descriptionClosure: (() -> String)?
|
|
|
|
open override func description() -> String {
|
|
descriptionCallsCountLock.withLock { descriptionUnderlyingCallsCount += 1 }
|
|
if let descriptionClosure = descriptionClosure {
|
|
return descriptionClosure()
|
|
} else {
|
|
return descriptionReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - symbol
|
|
|
|
private let symbolCallsCountLock = NSLock()
|
|
private var symbolUnderlyingCallsCount = 0
|
|
open var symbolCallsCount: Int {
|
|
get { symbolCallsCountLock.withLock { symbolUnderlyingCallsCount } }
|
|
set { symbolCallsCountLock.withLock { symbolUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var symbolCalled: Bool {
|
|
return symbolCallsCount > 0
|
|
}
|
|
|
|
private let symbolReturnValueLock = NSLock()
|
|
open var symbolUnderlyingReturnValue: String!
|
|
open var symbolReturnValue: String! {
|
|
get { symbolReturnValueLock.withLock { symbolUnderlyingReturnValue } }
|
|
set { symbolReturnValueLock.withLock { symbolUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var symbolClosure: (() -> String)?
|
|
|
|
open override func symbol() -> String {
|
|
symbolCallsCountLock.withLock { symbolUnderlyingCallsCount += 1 }
|
|
if let symbolClosure = symbolClosure {
|
|
return symbolClosure()
|
|
} else {
|
|
return symbolReturnValue
|
|
}
|
|
}
|
|
}
|
|
open class SpaceRoomListSDKMock: MatrixRustSDK.SpaceRoomList, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
|
|
//MARK: - paginate
|
|
|
|
open var paginateThrowableError: Error?
|
|
private let paginateCallsCountLock = NSLock()
|
|
private var paginateUnderlyingCallsCount = 0
|
|
open var paginateCallsCount: Int {
|
|
get { paginateCallsCountLock.withLock { paginateUnderlyingCallsCount } }
|
|
set { paginateCallsCountLock.withLock { paginateUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var paginateCalled: Bool {
|
|
return paginateCallsCount > 0
|
|
}
|
|
open var paginateClosure: (() async throws -> Void)?
|
|
|
|
open override func paginate() async throws {
|
|
if let error = paginateThrowableError {
|
|
throw error
|
|
}
|
|
paginateCallsCountLock.withLock { paginateUnderlyingCallsCount += 1 }
|
|
try await paginateClosure?()
|
|
}
|
|
|
|
//MARK: - paginationState
|
|
|
|
private let paginationStateCallsCountLock = NSLock()
|
|
private var paginationStateUnderlyingCallsCount = 0
|
|
open var paginationStateCallsCount: Int {
|
|
get { paginationStateCallsCountLock.withLock { paginationStateUnderlyingCallsCount } }
|
|
set { paginationStateCallsCountLock.withLock { paginationStateUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var paginationStateCalled: Bool {
|
|
return paginationStateCallsCount > 0
|
|
}
|
|
|
|
private let paginationStateReturnValueLock = NSLock()
|
|
open var paginationStateUnderlyingReturnValue: SpaceRoomListPaginationState!
|
|
open var paginationStateReturnValue: SpaceRoomListPaginationState! {
|
|
get { paginationStateReturnValueLock.withLock { paginationStateUnderlyingReturnValue } }
|
|
set { paginationStateReturnValueLock.withLock { paginationStateUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var paginationStateClosure: (() -> SpaceRoomListPaginationState)?
|
|
|
|
open override func paginationState() -> SpaceRoomListPaginationState {
|
|
paginationStateCallsCountLock.withLock { paginationStateUnderlyingCallsCount += 1 }
|
|
if let paginationStateClosure = paginationStateClosure {
|
|
return paginationStateClosure()
|
|
} else {
|
|
return paginationStateReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - reset
|
|
|
|
private let resetCallsCountLock = NSLock()
|
|
private var resetUnderlyingCallsCount = 0
|
|
open var resetCallsCount: Int {
|
|
get { resetCallsCountLock.withLock { resetUnderlyingCallsCount } }
|
|
set { resetCallsCountLock.withLock { resetUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var resetCalled: Bool {
|
|
return resetCallsCount > 0
|
|
}
|
|
open var resetClosure: (() async -> Void)?
|
|
|
|
open override func reset() async {
|
|
resetCallsCountLock.withLock { resetUnderlyingCallsCount += 1 }
|
|
await resetClosure?()
|
|
}
|
|
|
|
//MARK: - rooms
|
|
|
|
private let roomsCallsCountLock = NSLock()
|
|
private var roomsUnderlyingCallsCount = 0
|
|
open var roomsCallsCount: Int {
|
|
get { roomsCallsCountLock.withLock { roomsUnderlyingCallsCount } }
|
|
set { roomsCallsCountLock.withLock { roomsUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var roomsCalled: Bool {
|
|
return roomsCallsCount > 0
|
|
}
|
|
|
|
private let roomsReturnValueLock = NSLock()
|
|
open var roomsUnderlyingReturnValue: [SpaceRoom]!
|
|
open var roomsReturnValue: [SpaceRoom]! {
|
|
get { roomsReturnValueLock.withLock { roomsUnderlyingReturnValue } }
|
|
set { roomsReturnValueLock.withLock { roomsUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var roomsClosure: (() async -> [SpaceRoom])?
|
|
|
|
open override func rooms() async -> [SpaceRoom] {
|
|
roomsCallsCountLock.withLock { roomsUnderlyingCallsCount += 1 }
|
|
if let roomsClosure = roomsClosure {
|
|
return await roomsClosure()
|
|
} else {
|
|
return roomsReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - space
|
|
|
|
private let spaceCallsCountLock = NSLock()
|
|
private var spaceUnderlyingCallsCount = 0
|
|
open var spaceCallsCount: Int {
|
|
get { spaceCallsCountLock.withLock { spaceUnderlyingCallsCount } }
|
|
set { spaceCallsCountLock.withLock { spaceUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var spaceCalled: Bool {
|
|
return spaceCallsCount > 0
|
|
}
|
|
|
|
private let spaceReturnValueLock = NSLock()
|
|
open var spaceUnderlyingReturnValue: SpaceRoom?
|
|
open var spaceReturnValue: SpaceRoom? {
|
|
get { spaceReturnValueLock.withLock { spaceUnderlyingReturnValue } }
|
|
set { spaceReturnValueLock.withLock { spaceUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var spaceClosure: (() -> SpaceRoom?)?
|
|
|
|
open override func space() -> SpaceRoom? {
|
|
spaceCallsCountLock.withLock { spaceUnderlyingCallsCount += 1 }
|
|
if let spaceClosure = spaceClosure {
|
|
return spaceClosure()
|
|
} else {
|
|
return spaceReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - subscribeToPaginationStateUpdates
|
|
|
|
private let subscribeToPaginationStateUpdatesListenerCallsCountLock = NSLock()
|
|
private var subscribeToPaginationStateUpdatesListenerUnderlyingCallsCount = 0
|
|
open var subscribeToPaginationStateUpdatesListenerCallsCount: Int {
|
|
get { subscribeToPaginationStateUpdatesListenerCallsCountLock.withLock { subscribeToPaginationStateUpdatesListenerUnderlyingCallsCount } }
|
|
set { subscribeToPaginationStateUpdatesListenerCallsCountLock.withLock { subscribeToPaginationStateUpdatesListenerUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var subscribeToPaginationStateUpdatesListenerCalled: Bool {
|
|
return subscribeToPaginationStateUpdatesListenerCallsCount > 0
|
|
}
|
|
private let subscribeToPaginationStateUpdatesListenerReceivedListenerLock = NSLock()
|
|
private var subscribeToPaginationStateUpdatesListenerUnderlyingReceivedListener: SpaceRoomListPaginationStateListener?
|
|
open var subscribeToPaginationStateUpdatesListenerReceivedListener: SpaceRoomListPaginationStateListener? {
|
|
get { subscribeToPaginationStateUpdatesListenerReceivedListenerLock.withLock { subscribeToPaginationStateUpdatesListenerUnderlyingReceivedListener } }
|
|
set { subscribeToPaginationStateUpdatesListenerReceivedListenerLock.withLock { subscribeToPaginationStateUpdatesListenerUnderlyingReceivedListener = newValue } }
|
|
}
|
|
private let subscribeToPaginationStateUpdatesListenerReceivedInvocationsLock = NSLock()
|
|
private var subscribeToPaginationStateUpdatesListenerUnderlyingReceivedInvocations: [SpaceRoomListPaginationStateListener] = []
|
|
open var subscribeToPaginationStateUpdatesListenerReceivedInvocations: [SpaceRoomListPaginationStateListener] {
|
|
get { subscribeToPaginationStateUpdatesListenerReceivedInvocationsLock.withLock { subscribeToPaginationStateUpdatesListenerUnderlyingReceivedInvocations } }
|
|
set { subscribeToPaginationStateUpdatesListenerReceivedInvocationsLock.withLock { subscribeToPaginationStateUpdatesListenerUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let subscribeToPaginationStateUpdatesListenerReturnValueLock = NSLock()
|
|
open var subscribeToPaginationStateUpdatesListenerUnderlyingReturnValue: TaskHandle!
|
|
open var subscribeToPaginationStateUpdatesListenerReturnValue: TaskHandle! {
|
|
get { subscribeToPaginationStateUpdatesListenerReturnValueLock.withLock { subscribeToPaginationStateUpdatesListenerUnderlyingReturnValue } }
|
|
set { subscribeToPaginationStateUpdatesListenerReturnValueLock.withLock { subscribeToPaginationStateUpdatesListenerUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var subscribeToPaginationStateUpdatesListenerClosure: ((SpaceRoomListPaginationStateListener) -> TaskHandle)?
|
|
|
|
open override func subscribeToPaginationStateUpdates(listener: SpaceRoomListPaginationStateListener) -> TaskHandle {
|
|
subscribeToPaginationStateUpdatesListenerCallsCountLock.withLock { subscribeToPaginationStateUpdatesListenerUnderlyingCallsCount += 1 }
|
|
subscribeToPaginationStateUpdatesListenerReceivedListener = listener
|
|
subscribeToPaginationStateUpdatesListenerReceivedInvocationsLock.withLock { subscribeToPaginationStateUpdatesListenerUnderlyingReceivedInvocations.append(listener) }
|
|
if let subscribeToPaginationStateUpdatesListenerClosure = subscribeToPaginationStateUpdatesListenerClosure {
|
|
return subscribeToPaginationStateUpdatesListenerClosure(listener)
|
|
} else {
|
|
return subscribeToPaginationStateUpdatesListenerReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - subscribeToRoomUpdate
|
|
|
|
private let subscribeToRoomUpdateListenerCallsCountLock = NSLock()
|
|
private var subscribeToRoomUpdateListenerUnderlyingCallsCount = 0
|
|
open var subscribeToRoomUpdateListenerCallsCount: Int {
|
|
get { subscribeToRoomUpdateListenerCallsCountLock.withLock { subscribeToRoomUpdateListenerUnderlyingCallsCount } }
|
|
set { subscribeToRoomUpdateListenerCallsCountLock.withLock { subscribeToRoomUpdateListenerUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var subscribeToRoomUpdateListenerCalled: Bool {
|
|
return subscribeToRoomUpdateListenerCallsCount > 0
|
|
}
|
|
private let subscribeToRoomUpdateListenerReceivedListenerLock = NSLock()
|
|
private var subscribeToRoomUpdateListenerUnderlyingReceivedListener: SpaceRoomListEntriesListener?
|
|
open var subscribeToRoomUpdateListenerReceivedListener: SpaceRoomListEntriesListener? {
|
|
get { subscribeToRoomUpdateListenerReceivedListenerLock.withLock { subscribeToRoomUpdateListenerUnderlyingReceivedListener } }
|
|
set { subscribeToRoomUpdateListenerReceivedListenerLock.withLock { subscribeToRoomUpdateListenerUnderlyingReceivedListener = newValue } }
|
|
}
|
|
private let subscribeToRoomUpdateListenerReceivedInvocationsLock = NSLock()
|
|
private var subscribeToRoomUpdateListenerUnderlyingReceivedInvocations: [SpaceRoomListEntriesListener] = []
|
|
open var subscribeToRoomUpdateListenerReceivedInvocations: [SpaceRoomListEntriesListener] {
|
|
get { subscribeToRoomUpdateListenerReceivedInvocationsLock.withLock { subscribeToRoomUpdateListenerUnderlyingReceivedInvocations } }
|
|
set { subscribeToRoomUpdateListenerReceivedInvocationsLock.withLock { subscribeToRoomUpdateListenerUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let subscribeToRoomUpdateListenerReturnValueLock = NSLock()
|
|
open var subscribeToRoomUpdateListenerUnderlyingReturnValue: TaskHandle!
|
|
open var subscribeToRoomUpdateListenerReturnValue: TaskHandle! {
|
|
get { subscribeToRoomUpdateListenerReturnValueLock.withLock { subscribeToRoomUpdateListenerUnderlyingReturnValue } }
|
|
set { subscribeToRoomUpdateListenerReturnValueLock.withLock { subscribeToRoomUpdateListenerUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var subscribeToRoomUpdateListenerClosure: ((SpaceRoomListEntriesListener) async -> TaskHandle)?
|
|
|
|
open override func subscribeToRoomUpdate(listener: SpaceRoomListEntriesListener) async -> TaskHandle {
|
|
subscribeToRoomUpdateListenerCallsCountLock.withLock { subscribeToRoomUpdateListenerUnderlyingCallsCount += 1 }
|
|
subscribeToRoomUpdateListenerReceivedListener = listener
|
|
subscribeToRoomUpdateListenerReceivedInvocationsLock.withLock { subscribeToRoomUpdateListenerUnderlyingReceivedInvocations.append(listener) }
|
|
if let subscribeToRoomUpdateListenerClosure = subscribeToRoomUpdateListenerClosure {
|
|
return await subscribeToRoomUpdateListenerClosure(listener)
|
|
} else {
|
|
return subscribeToRoomUpdateListenerReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - subscribeToSpaceUpdates
|
|
|
|
private let subscribeToSpaceUpdatesListenerCallsCountLock = NSLock()
|
|
private var subscribeToSpaceUpdatesListenerUnderlyingCallsCount = 0
|
|
open var subscribeToSpaceUpdatesListenerCallsCount: Int {
|
|
get { subscribeToSpaceUpdatesListenerCallsCountLock.withLock { subscribeToSpaceUpdatesListenerUnderlyingCallsCount } }
|
|
set { subscribeToSpaceUpdatesListenerCallsCountLock.withLock { subscribeToSpaceUpdatesListenerUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var subscribeToSpaceUpdatesListenerCalled: Bool {
|
|
return subscribeToSpaceUpdatesListenerCallsCount > 0
|
|
}
|
|
private let subscribeToSpaceUpdatesListenerReceivedListenerLock = NSLock()
|
|
private var subscribeToSpaceUpdatesListenerUnderlyingReceivedListener: SpaceRoomListSpaceListener?
|
|
open var subscribeToSpaceUpdatesListenerReceivedListener: SpaceRoomListSpaceListener? {
|
|
get { subscribeToSpaceUpdatesListenerReceivedListenerLock.withLock { subscribeToSpaceUpdatesListenerUnderlyingReceivedListener } }
|
|
set { subscribeToSpaceUpdatesListenerReceivedListenerLock.withLock { subscribeToSpaceUpdatesListenerUnderlyingReceivedListener = newValue } }
|
|
}
|
|
private let subscribeToSpaceUpdatesListenerReceivedInvocationsLock = NSLock()
|
|
private var subscribeToSpaceUpdatesListenerUnderlyingReceivedInvocations: [SpaceRoomListSpaceListener] = []
|
|
open var subscribeToSpaceUpdatesListenerReceivedInvocations: [SpaceRoomListSpaceListener] {
|
|
get { subscribeToSpaceUpdatesListenerReceivedInvocationsLock.withLock { subscribeToSpaceUpdatesListenerUnderlyingReceivedInvocations } }
|
|
set { subscribeToSpaceUpdatesListenerReceivedInvocationsLock.withLock { subscribeToSpaceUpdatesListenerUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let subscribeToSpaceUpdatesListenerReturnValueLock = NSLock()
|
|
open var subscribeToSpaceUpdatesListenerUnderlyingReturnValue: TaskHandle!
|
|
open var subscribeToSpaceUpdatesListenerReturnValue: TaskHandle! {
|
|
get { subscribeToSpaceUpdatesListenerReturnValueLock.withLock { subscribeToSpaceUpdatesListenerUnderlyingReturnValue } }
|
|
set { subscribeToSpaceUpdatesListenerReturnValueLock.withLock { subscribeToSpaceUpdatesListenerUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var subscribeToSpaceUpdatesListenerClosure: ((SpaceRoomListSpaceListener) -> TaskHandle)?
|
|
|
|
open override func subscribeToSpaceUpdates(listener: SpaceRoomListSpaceListener) -> TaskHandle {
|
|
subscribeToSpaceUpdatesListenerCallsCountLock.withLock { subscribeToSpaceUpdatesListenerUnderlyingCallsCount += 1 }
|
|
subscribeToSpaceUpdatesListenerReceivedListener = listener
|
|
subscribeToSpaceUpdatesListenerReceivedInvocationsLock.withLock { subscribeToSpaceUpdatesListenerUnderlyingReceivedInvocations.append(listener) }
|
|
if let subscribeToSpaceUpdatesListenerClosure = subscribeToSpaceUpdatesListenerClosure {
|
|
return subscribeToSpaceUpdatesListenerClosure(listener)
|
|
} else {
|
|
return subscribeToSpaceUpdatesListenerReturnValue
|
|
}
|
|
}
|
|
}
|
|
open class SpaceServiceSDKMock: MatrixRustSDK.SpaceService, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
|
|
//MARK: - addChildToSpace
|
|
|
|
open var addChildToSpaceChildIdSpaceIdThrowableError: Error?
|
|
private let addChildToSpaceChildIdSpaceIdCallsCountLock = NSLock()
|
|
private var addChildToSpaceChildIdSpaceIdUnderlyingCallsCount = 0
|
|
open var addChildToSpaceChildIdSpaceIdCallsCount: Int {
|
|
get { addChildToSpaceChildIdSpaceIdCallsCountLock.withLock { addChildToSpaceChildIdSpaceIdUnderlyingCallsCount } }
|
|
set { addChildToSpaceChildIdSpaceIdCallsCountLock.withLock { addChildToSpaceChildIdSpaceIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var addChildToSpaceChildIdSpaceIdCalled: Bool {
|
|
return addChildToSpaceChildIdSpaceIdCallsCount > 0
|
|
}
|
|
private let addChildToSpaceChildIdSpaceIdReceivedArgumentsLock = NSLock()
|
|
private var addChildToSpaceChildIdSpaceIdUnderlyingReceivedArguments: (childId: String, spaceId: String)?
|
|
open var addChildToSpaceChildIdSpaceIdReceivedArguments: (childId: String, spaceId: String)? {
|
|
get { addChildToSpaceChildIdSpaceIdReceivedArgumentsLock.withLock { addChildToSpaceChildIdSpaceIdUnderlyingReceivedArguments } }
|
|
set { addChildToSpaceChildIdSpaceIdReceivedArgumentsLock.withLock { addChildToSpaceChildIdSpaceIdUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let addChildToSpaceChildIdSpaceIdReceivedInvocationsLock = NSLock()
|
|
private var addChildToSpaceChildIdSpaceIdUnderlyingReceivedInvocations: [(childId: String, spaceId: String)] = []
|
|
open var addChildToSpaceChildIdSpaceIdReceivedInvocations: [(childId: String, spaceId: String)] {
|
|
get { addChildToSpaceChildIdSpaceIdReceivedInvocationsLock.withLock { addChildToSpaceChildIdSpaceIdUnderlyingReceivedInvocations } }
|
|
set { addChildToSpaceChildIdSpaceIdReceivedInvocationsLock.withLock { addChildToSpaceChildIdSpaceIdUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var addChildToSpaceChildIdSpaceIdClosure: ((String, String) async throws -> Void)?
|
|
|
|
open override func addChildToSpace(childId: String, spaceId: String) async throws {
|
|
if let error = addChildToSpaceChildIdSpaceIdThrowableError {
|
|
throw error
|
|
}
|
|
addChildToSpaceChildIdSpaceIdCallsCountLock.withLock { addChildToSpaceChildIdSpaceIdUnderlyingCallsCount += 1 }
|
|
addChildToSpaceChildIdSpaceIdReceivedArguments = (childId: childId, spaceId: spaceId)
|
|
addChildToSpaceChildIdSpaceIdReceivedInvocationsLock.withLock { addChildToSpaceChildIdSpaceIdUnderlyingReceivedInvocations.append((childId: childId, spaceId: spaceId)) }
|
|
try await addChildToSpaceChildIdSpaceIdClosure?(childId, spaceId)
|
|
}
|
|
|
|
//MARK: - editableSpaces
|
|
|
|
private let editableSpacesCallsCountLock = NSLock()
|
|
private var editableSpacesUnderlyingCallsCount = 0
|
|
open var editableSpacesCallsCount: Int {
|
|
get { editableSpacesCallsCountLock.withLock { editableSpacesUnderlyingCallsCount } }
|
|
set { editableSpacesCallsCountLock.withLock { editableSpacesUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var editableSpacesCalled: Bool {
|
|
return editableSpacesCallsCount > 0
|
|
}
|
|
|
|
private let editableSpacesReturnValueLock = NSLock()
|
|
open var editableSpacesUnderlyingReturnValue: [SpaceRoom]!
|
|
open var editableSpacesReturnValue: [SpaceRoom]! {
|
|
get { editableSpacesReturnValueLock.withLock { editableSpacesUnderlyingReturnValue } }
|
|
set { editableSpacesReturnValueLock.withLock { editableSpacesUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var editableSpacesClosure: (() async -> [SpaceRoom])?
|
|
|
|
open override func editableSpaces() async -> [SpaceRoom] {
|
|
editableSpacesCallsCountLock.withLock { editableSpacesUnderlyingCallsCount += 1 }
|
|
if let editableSpacesClosure = editableSpacesClosure {
|
|
return await editableSpacesClosure()
|
|
} else {
|
|
return editableSpacesReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - getSpaceRoom
|
|
|
|
open var getSpaceRoomRoomIdThrowableError: Error?
|
|
private let getSpaceRoomRoomIdCallsCountLock = NSLock()
|
|
private var getSpaceRoomRoomIdUnderlyingCallsCount = 0
|
|
open var getSpaceRoomRoomIdCallsCount: Int {
|
|
get { getSpaceRoomRoomIdCallsCountLock.withLock { getSpaceRoomRoomIdUnderlyingCallsCount } }
|
|
set { getSpaceRoomRoomIdCallsCountLock.withLock { getSpaceRoomRoomIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var getSpaceRoomRoomIdCalled: Bool {
|
|
return getSpaceRoomRoomIdCallsCount > 0
|
|
}
|
|
private let getSpaceRoomRoomIdReceivedRoomIdLock = NSLock()
|
|
private var getSpaceRoomRoomIdUnderlyingReceivedRoomId: String?
|
|
open var getSpaceRoomRoomIdReceivedRoomId: String? {
|
|
get { getSpaceRoomRoomIdReceivedRoomIdLock.withLock { getSpaceRoomRoomIdUnderlyingReceivedRoomId } }
|
|
set { getSpaceRoomRoomIdReceivedRoomIdLock.withLock { getSpaceRoomRoomIdUnderlyingReceivedRoomId = newValue } }
|
|
}
|
|
private let getSpaceRoomRoomIdReceivedInvocationsLock = NSLock()
|
|
private var getSpaceRoomRoomIdUnderlyingReceivedInvocations: [String] = []
|
|
open var getSpaceRoomRoomIdReceivedInvocations: [String] {
|
|
get { getSpaceRoomRoomIdReceivedInvocationsLock.withLock { getSpaceRoomRoomIdUnderlyingReceivedInvocations } }
|
|
set { getSpaceRoomRoomIdReceivedInvocationsLock.withLock { getSpaceRoomRoomIdUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let getSpaceRoomRoomIdReturnValueLock = NSLock()
|
|
open var getSpaceRoomRoomIdUnderlyingReturnValue: SpaceRoom?
|
|
open var getSpaceRoomRoomIdReturnValue: SpaceRoom? {
|
|
get { getSpaceRoomRoomIdReturnValueLock.withLock { getSpaceRoomRoomIdUnderlyingReturnValue } }
|
|
set { getSpaceRoomRoomIdReturnValueLock.withLock { getSpaceRoomRoomIdUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var getSpaceRoomRoomIdClosure: ((String) async throws -> SpaceRoom?)?
|
|
|
|
open override func getSpaceRoom(roomId: String) async throws -> SpaceRoom? {
|
|
if let error = getSpaceRoomRoomIdThrowableError {
|
|
throw error
|
|
}
|
|
getSpaceRoomRoomIdCallsCountLock.withLock { getSpaceRoomRoomIdUnderlyingCallsCount += 1 }
|
|
getSpaceRoomRoomIdReceivedRoomId = roomId
|
|
getSpaceRoomRoomIdReceivedInvocationsLock.withLock { getSpaceRoomRoomIdUnderlyingReceivedInvocations.append(roomId) }
|
|
if let getSpaceRoomRoomIdClosure = getSpaceRoomRoomIdClosure {
|
|
return try await getSpaceRoomRoomIdClosure(roomId)
|
|
} else {
|
|
return getSpaceRoomRoomIdReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - joinedParentsOfChild
|
|
|
|
open var joinedParentsOfChildChildIdThrowableError: Error?
|
|
private let joinedParentsOfChildChildIdCallsCountLock = NSLock()
|
|
private var joinedParentsOfChildChildIdUnderlyingCallsCount = 0
|
|
open var joinedParentsOfChildChildIdCallsCount: Int {
|
|
get { joinedParentsOfChildChildIdCallsCountLock.withLock { joinedParentsOfChildChildIdUnderlyingCallsCount } }
|
|
set { joinedParentsOfChildChildIdCallsCountLock.withLock { joinedParentsOfChildChildIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var joinedParentsOfChildChildIdCalled: Bool {
|
|
return joinedParentsOfChildChildIdCallsCount > 0
|
|
}
|
|
private let joinedParentsOfChildChildIdReceivedChildIdLock = NSLock()
|
|
private var joinedParentsOfChildChildIdUnderlyingReceivedChildId: String?
|
|
open var joinedParentsOfChildChildIdReceivedChildId: String? {
|
|
get { joinedParentsOfChildChildIdReceivedChildIdLock.withLock { joinedParentsOfChildChildIdUnderlyingReceivedChildId } }
|
|
set { joinedParentsOfChildChildIdReceivedChildIdLock.withLock { joinedParentsOfChildChildIdUnderlyingReceivedChildId = newValue } }
|
|
}
|
|
private let joinedParentsOfChildChildIdReceivedInvocationsLock = NSLock()
|
|
private var joinedParentsOfChildChildIdUnderlyingReceivedInvocations: [String] = []
|
|
open var joinedParentsOfChildChildIdReceivedInvocations: [String] {
|
|
get { joinedParentsOfChildChildIdReceivedInvocationsLock.withLock { joinedParentsOfChildChildIdUnderlyingReceivedInvocations } }
|
|
set { joinedParentsOfChildChildIdReceivedInvocationsLock.withLock { joinedParentsOfChildChildIdUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let joinedParentsOfChildChildIdReturnValueLock = NSLock()
|
|
open var joinedParentsOfChildChildIdUnderlyingReturnValue: [SpaceRoom]!
|
|
open var joinedParentsOfChildChildIdReturnValue: [SpaceRoom]! {
|
|
get { joinedParentsOfChildChildIdReturnValueLock.withLock { joinedParentsOfChildChildIdUnderlyingReturnValue } }
|
|
set { joinedParentsOfChildChildIdReturnValueLock.withLock { joinedParentsOfChildChildIdUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var joinedParentsOfChildChildIdClosure: ((String) async throws -> [SpaceRoom])?
|
|
|
|
open override func joinedParentsOfChild(childId: String) async throws -> [SpaceRoom] {
|
|
if let error = joinedParentsOfChildChildIdThrowableError {
|
|
throw error
|
|
}
|
|
joinedParentsOfChildChildIdCallsCountLock.withLock { joinedParentsOfChildChildIdUnderlyingCallsCount += 1 }
|
|
joinedParentsOfChildChildIdReceivedChildId = childId
|
|
joinedParentsOfChildChildIdReceivedInvocationsLock.withLock { joinedParentsOfChildChildIdUnderlyingReceivedInvocations.append(childId) }
|
|
if let joinedParentsOfChildChildIdClosure = joinedParentsOfChildChildIdClosure {
|
|
return try await joinedParentsOfChildChildIdClosure(childId)
|
|
} else {
|
|
return joinedParentsOfChildChildIdReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - leaveSpace
|
|
|
|
open var leaveSpaceSpaceIdThrowableError: Error?
|
|
private let leaveSpaceSpaceIdCallsCountLock = NSLock()
|
|
private var leaveSpaceSpaceIdUnderlyingCallsCount = 0
|
|
open var leaveSpaceSpaceIdCallsCount: Int {
|
|
get { leaveSpaceSpaceIdCallsCountLock.withLock { leaveSpaceSpaceIdUnderlyingCallsCount } }
|
|
set { leaveSpaceSpaceIdCallsCountLock.withLock { leaveSpaceSpaceIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var leaveSpaceSpaceIdCalled: Bool {
|
|
return leaveSpaceSpaceIdCallsCount > 0
|
|
}
|
|
private let leaveSpaceSpaceIdReceivedSpaceIdLock = NSLock()
|
|
private var leaveSpaceSpaceIdUnderlyingReceivedSpaceId: String?
|
|
open var leaveSpaceSpaceIdReceivedSpaceId: String? {
|
|
get { leaveSpaceSpaceIdReceivedSpaceIdLock.withLock { leaveSpaceSpaceIdUnderlyingReceivedSpaceId } }
|
|
set { leaveSpaceSpaceIdReceivedSpaceIdLock.withLock { leaveSpaceSpaceIdUnderlyingReceivedSpaceId = newValue } }
|
|
}
|
|
private let leaveSpaceSpaceIdReceivedInvocationsLock = NSLock()
|
|
private var leaveSpaceSpaceIdUnderlyingReceivedInvocations: [String] = []
|
|
open var leaveSpaceSpaceIdReceivedInvocations: [String] {
|
|
get { leaveSpaceSpaceIdReceivedInvocationsLock.withLock { leaveSpaceSpaceIdUnderlyingReceivedInvocations } }
|
|
set { leaveSpaceSpaceIdReceivedInvocationsLock.withLock { leaveSpaceSpaceIdUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let leaveSpaceSpaceIdReturnValueLock = NSLock()
|
|
open var leaveSpaceSpaceIdUnderlyingReturnValue: LeaveSpaceHandle!
|
|
open var leaveSpaceSpaceIdReturnValue: LeaveSpaceHandle! {
|
|
get { leaveSpaceSpaceIdReturnValueLock.withLock { leaveSpaceSpaceIdUnderlyingReturnValue } }
|
|
set { leaveSpaceSpaceIdReturnValueLock.withLock { leaveSpaceSpaceIdUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var leaveSpaceSpaceIdClosure: ((String) async throws -> LeaveSpaceHandle)?
|
|
|
|
open override func leaveSpace(spaceId: String) async throws -> LeaveSpaceHandle {
|
|
if let error = leaveSpaceSpaceIdThrowableError {
|
|
throw error
|
|
}
|
|
leaveSpaceSpaceIdCallsCountLock.withLock { leaveSpaceSpaceIdUnderlyingCallsCount += 1 }
|
|
leaveSpaceSpaceIdReceivedSpaceId = spaceId
|
|
leaveSpaceSpaceIdReceivedInvocationsLock.withLock { leaveSpaceSpaceIdUnderlyingReceivedInvocations.append(spaceId) }
|
|
if let leaveSpaceSpaceIdClosure = leaveSpaceSpaceIdClosure {
|
|
return try await leaveSpaceSpaceIdClosure(spaceId)
|
|
} else {
|
|
return leaveSpaceSpaceIdReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - removeChildFromSpace
|
|
|
|
open var removeChildFromSpaceChildIdSpaceIdThrowableError: Error?
|
|
private let removeChildFromSpaceChildIdSpaceIdCallsCountLock = NSLock()
|
|
private var removeChildFromSpaceChildIdSpaceIdUnderlyingCallsCount = 0
|
|
open var removeChildFromSpaceChildIdSpaceIdCallsCount: Int {
|
|
get { removeChildFromSpaceChildIdSpaceIdCallsCountLock.withLock { removeChildFromSpaceChildIdSpaceIdUnderlyingCallsCount } }
|
|
set { removeChildFromSpaceChildIdSpaceIdCallsCountLock.withLock { removeChildFromSpaceChildIdSpaceIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var removeChildFromSpaceChildIdSpaceIdCalled: Bool {
|
|
return removeChildFromSpaceChildIdSpaceIdCallsCount > 0
|
|
}
|
|
private let removeChildFromSpaceChildIdSpaceIdReceivedArgumentsLock = NSLock()
|
|
private var removeChildFromSpaceChildIdSpaceIdUnderlyingReceivedArguments: (childId: String, spaceId: String)?
|
|
open var removeChildFromSpaceChildIdSpaceIdReceivedArguments: (childId: String, spaceId: String)? {
|
|
get { removeChildFromSpaceChildIdSpaceIdReceivedArgumentsLock.withLock { removeChildFromSpaceChildIdSpaceIdUnderlyingReceivedArguments } }
|
|
set { removeChildFromSpaceChildIdSpaceIdReceivedArgumentsLock.withLock { removeChildFromSpaceChildIdSpaceIdUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let removeChildFromSpaceChildIdSpaceIdReceivedInvocationsLock = NSLock()
|
|
private var removeChildFromSpaceChildIdSpaceIdUnderlyingReceivedInvocations: [(childId: String, spaceId: String)] = []
|
|
open var removeChildFromSpaceChildIdSpaceIdReceivedInvocations: [(childId: String, spaceId: String)] {
|
|
get { removeChildFromSpaceChildIdSpaceIdReceivedInvocationsLock.withLock { removeChildFromSpaceChildIdSpaceIdUnderlyingReceivedInvocations } }
|
|
set { removeChildFromSpaceChildIdSpaceIdReceivedInvocationsLock.withLock { removeChildFromSpaceChildIdSpaceIdUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var removeChildFromSpaceChildIdSpaceIdClosure: ((String, String) async throws -> Void)?
|
|
|
|
open override func removeChildFromSpace(childId: String, spaceId: String) async throws {
|
|
if let error = removeChildFromSpaceChildIdSpaceIdThrowableError {
|
|
throw error
|
|
}
|
|
removeChildFromSpaceChildIdSpaceIdCallsCountLock.withLock { removeChildFromSpaceChildIdSpaceIdUnderlyingCallsCount += 1 }
|
|
removeChildFromSpaceChildIdSpaceIdReceivedArguments = (childId: childId, spaceId: spaceId)
|
|
removeChildFromSpaceChildIdSpaceIdReceivedInvocationsLock.withLock { removeChildFromSpaceChildIdSpaceIdUnderlyingReceivedInvocations.append((childId: childId, spaceId: spaceId)) }
|
|
try await removeChildFromSpaceChildIdSpaceIdClosure?(childId, spaceId)
|
|
}
|
|
|
|
//MARK: - spaceFilters
|
|
|
|
private let spaceFiltersCallsCountLock = NSLock()
|
|
private var spaceFiltersUnderlyingCallsCount = 0
|
|
open var spaceFiltersCallsCount: Int {
|
|
get { spaceFiltersCallsCountLock.withLock { spaceFiltersUnderlyingCallsCount } }
|
|
set { spaceFiltersCallsCountLock.withLock { spaceFiltersUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var spaceFiltersCalled: Bool {
|
|
return spaceFiltersCallsCount > 0
|
|
}
|
|
|
|
private let spaceFiltersReturnValueLock = NSLock()
|
|
open var spaceFiltersUnderlyingReturnValue: [SpaceFilter]!
|
|
open var spaceFiltersReturnValue: [SpaceFilter]! {
|
|
get { spaceFiltersReturnValueLock.withLock { spaceFiltersUnderlyingReturnValue } }
|
|
set { spaceFiltersReturnValueLock.withLock { spaceFiltersUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var spaceFiltersClosure: (() async -> [SpaceFilter])?
|
|
|
|
open override func spaceFilters() async -> [SpaceFilter] {
|
|
spaceFiltersCallsCountLock.withLock { spaceFiltersUnderlyingCallsCount += 1 }
|
|
if let spaceFiltersClosure = spaceFiltersClosure {
|
|
return await spaceFiltersClosure()
|
|
} else {
|
|
return spaceFiltersReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - spaceRoomList
|
|
|
|
open var spaceRoomListSpaceIdThrowableError: Error?
|
|
private let spaceRoomListSpaceIdCallsCountLock = NSLock()
|
|
private var spaceRoomListSpaceIdUnderlyingCallsCount = 0
|
|
open var spaceRoomListSpaceIdCallsCount: Int {
|
|
get { spaceRoomListSpaceIdCallsCountLock.withLock { spaceRoomListSpaceIdUnderlyingCallsCount } }
|
|
set { spaceRoomListSpaceIdCallsCountLock.withLock { spaceRoomListSpaceIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var spaceRoomListSpaceIdCalled: Bool {
|
|
return spaceRoomListSpaceIdCallsCount > 0
|
|
}
|
|
private let spaceRoomListSpaceIdReceivedSpaceIdLock = NSLock()
|
|
private var spaceRoomListSpaceIdUnderlyingReceivedSpaceId: String?
|
|
open var spaceRoomListSpaceIdReceivedSpaceId: String? {
|
|
get { spaceRoomListSpaceIdReceivedSpaceIdLock.withLock { spaceRoomListSpaceIdUnderlyingReceivedSpaceId } }
|
|
set { spaceRoomListSpaceIdReceivedSpaceIdLock.withLock { spaceRoomListSpaceIdUnderlyingReceivedSpaceId = newValue } }
|
|
}
|
|
private let spaceRoomListSpaceIdReceivedInvocationsLock = NSLock()
|
|
private var spaceRoomListSpaceIdUnderlyingReceivedInvocations: [String] = []
|
|
open var spaceRoomListSpaceIdReceivedInvocations: [String] {
|
|
get { spaceRoomListSpaceIdReceivedInvocationsLock.withLock { spaceRoomListSpaceIdUnderlyingReceivedInvocations } }
|
|
set { spaceRoomListSpaceIdReceivedInvocationsLock.withLock { spaceRoomListSpaceIdUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let spaceRoomListSpaceIdReturnValueLock = NSLock()
|
|
open var spaceRoomListSpaceIdUnderlyingReturnValue: SpaceRoomList!
|
|
open var spaceRoomListSpaceIdReturnValue: SpaceRoomList! {
|
|
get { spaceRoomListSpaceIdReturnValueLock.withLock { spaceRoomListSpaceIdUnderlyingReturnValue } }
|
|
set { spaceRoomListSpaceIdReturnValueLock.withLock { spaceRoomListSpaceIdUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var spaceRoomListSpaceIdClosure: ((String) async throws -> SpaceRoomList)?
|
|
|
|
open override func spaceRoomList(spaceId: String) async throws -> SpaceRoomList {
|
|
if let error = spaceRoomListSpaceIdThrowableError {
|
|
throw error
|
|
}
|
|
spaceRoomListSpaceIdCallsCountLock.withLock { spaceRoomListSpaceIdUnderlyingCallsCount += 1 }
|
|
spaceRoomListSpaceIdReceivedSpaceId = spaceId
|
|
spaceRoomListSpaceIdReceivedInvocationsLock.withLock { spaceRoomListSpaceIdUnderlyingReceivedInvocations.append(spaceId) }
|
|
if let spaceRoomListSpaceIdClosure = spaceRoomListSpaceIdClosure {
|
|
return try await spaceRoomListSpaceIdClosure(spaceId)
|
|
} else {
|
|
return spaceRoomListSpaceIdReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - subscribeToSpaceFilters
|
|
|
|
private let subscribeToSpaceFiltersListenerCallsCountLock = NSLock()
|
|
private var subscribeToSpaceFiltersListenerUnderlyingCallsCount = 0
|
|
open var subscribeToSpaceFiltersListenerCallsCount: Int {
|
|
get { subscribeToSpaceFiltersListenerCallsCountLock.withLock { subscribeToSpaceFiltersListenerUnderlyingCallsCount } }
|
|
set { subscribeToSpaceFiltersListenerCallsCountLock.withLock { subscribeToSpaceFiltersListenerUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var subscribeToSpaceFiltersListenerCalled: Bool {
|
|
return subscribeToSpaceFiltersListenerCallsCount > 0
|
|
}
|
|
private let subscribeToSpaceFiltersListenerReceivedListenerLock = NSLock()
|
|
private var subscribeToSpaceFiltersListenerUnderlyingReceivedListener: SpaceServiceSpaceFiltersListener?
|
|
open var subscribeToSpaceFiltersListenerReceivedListener: SpaceServiceSpaceFiltersListener? {
|
|
get { subscribeToSpaceFiltersListenerReceivedListenerLock.withLock { subscribeToSpaceFiltersListenerUnderlyingReceivedListener } }
|
|
set { subscribeToSpaceFiltersListenerReceivedListenerLock.withLock { subscribeToSpaceFiltersListenerUnderlyingReceivedListener = newValue } }
|
|
}
|
|
private let subscribeToSpaceFiltersListenerReceivedInvocationsLock = NSLock()
|
|
private var subscribeToSpaceFiltersListenerUnderlyingReceivedInvocations: [SpaceServiceSpaceFiltersListener] = []
|
|
open var subscribeToSpaceFiltersListenerReceivedInvocations: [SpaceServiceSpaceFiltersListener] {
|
|
get { subscribeToSpaceFiltersListenerReceivedInvocationsLock.withLock { subscribeToSpaceFiltersListenerUnderlyingReceivedInvocations } }
|
|
set { subscribeToSpaceFiltersListenerReceivedInvocationsLock.withLock { subscribeToSpaceFiltersListenerUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let subscribeToSpaceFiltersListenerReturnValueLock = NSLock()
|
|
open var subscribeToSpaceFiltersListenerUnderlyingReturnValue: TaskHandle!
|
|
open var subscribeToSpaceFiltersListenerReturnValue: TaskHandle! {
|
|
get { subscribeToSpaceFiltersListenerReturnValueLock.withLock { subscribeToSpaceFiltersListenerUnderlyingReturnValue } }
|
|
set { subscribeToSpaceFiltersListenerReturnValueLock.withLock { subscribeToSpaceFiltersListenerUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var subscribeToSpaceFiltersListenerClosure: ((SpaceServiceSpaceFiltersListener) async -> TaskHandle)?
|
|
|
|
open override func subscribeToSpaceFilters(listener: SpaceServiceSpaceFiltersListener) async -> TaskHandle {
|
|
subscribeToSpaceFiltersListenerCallsCountLock.withLock { subscribeToSpaceFiltersListenerUnderlyingCallsCount += 1 }
|
|
subscribeToSpaceFiltersListenerReceivedListener = listener
|
|
subscribeToSpaceFiltersListenerReceivedInvocationsLock.withLock { subscribeToSpaceFiltersListenerUnderlyingReceivedInvocations.append(listener) }
|
|
if let subscribeToSpaceFiltersListenerClosure = subscribeToSpaceFiltersListenerClosure {
|
|
return await subscribeToSpaceFiltersListenerClosure(listener)
|
|
} else {
|
|
return subscribeToSpaceFiltersListenerReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - subscribeToTopLevelJoinedSpaces
|
|
|
|
private let subscribeToTopLevelJoinedSpacesListenerCallsCountLock = NSLock()
|
|
private var subscribeToTopLevelJoinedSpacesListenerUnderlyingCallsCount = 0
|
|
open var subscribeToTopLevelJoinedSpacesListenerCallsCount: Int {
|
|
get { subscribeToTopLevelJoinedSpacesListenerCallsCountLock.withLock { subscribeToTopLevelJoinedSpacesListenerUnderlyingCallsCount } }
|
|
set { subscribeToTopLevelJoinedSpacesListenerCallsCountLock.withLock { subscribeToTopLevelJoinedSpacesListenerUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var subscribeToTopLevelJoinedSpacesListenerCalled: Bool {
|
|
return subscribeToTopLevelJoinedSpacesListenerCallsCount > 0
|
|
}
|
|
private let subscribeToTopLevelJoinedSpacesListenerReceivedListenerLock = NSLock()
|
|
private var subscribeToTopLevelJoinedSpacesListenerUnderlyingReceivedListener: SpaceServiceJoinedSpacesListener?
|
|
open var subscribeToTopLevelJoinedSpacesListenerReceivedListener: SpaceServiceJoinedSpacesListener? {
|
|
get { subscribeToTopLevelJoinedSpacesListenerReceivedListenerLock.withLock { subscribeToTopLevelJoinedSpacesListenerUnderlyingReceivedListener } }
|
|
set { subscribeToTopLevelJoinedSpacesListenerReceivedListenerLock.withLock { subscribeToTopLevelJoinedSpacesListenerUnderlyingReceivedListener = newValue } }
|
|
}
|
|
private let subscribeToTopLevelJoinedSpacesListenerReceivedInvocationsLock = NSLock()
|
|
private var subscribeToTopLevelJoinedSpacesListenerUnderlyingReceivedInvocations: [SpaceServiceJoinedSpacesListener] = []
|
|
open var subscribeToTopLevelJoinedSpacesListenerReceivedInvocations: [SpaceServiceJoinedSpacesListener] {
|
|
get { subscribeToTopLevelJoinedSpacesListenerReceivedInvocationsLock.withLock { subscribeToTopLevelJoinedSpacesListenerUnderlyingReceivedInvocations } }
|
|
set { subscribeToTopLevelJoinedSpacesListenerReceivedInvocationsLock.withLock { subscribeToTopLevelJoinedSpacesListenerUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let subscribeToTopLevelJoinedSpacesListenerReturnValueLock = NSLock()
|
|
open var subscribeToTopLevelJoinedSpacesListenerUnderlyingReturnValue: TaskHandle!
|
|
open var subscribeToTopLevelJoinedSpacesListenerReturnValue: TaskHandle! {
|
|
get { subscribeToTopLevelJoinedSpacesListenerReturnValueLock.withLock { subscribeToTopLevelJoinedSpacesListenerUnderlyingReturnValue } }
|
|
set { subscribeToTopLevelJoinedSpacesListenerReturnValueLock.withLock { subscribeToTopLevelJoinedSpacesListenerUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var subscribeToTopLevelJoinedSpacesListenerClosure: ((SpaceServiceJoinedSpacesListener) async -> TaskHandle)?
|
|
|
|
open override func subscribeToTopLevelJoinedSpaces(listener: SpaceServiceJoinedSpacesListener) async -> TaskHandle {
|
|
subscribeToTopLevelJoinedSpacesListenerCallsCountLock.withLock { subscribeToTopLevelJoinedSpacesListenerUnderlyingCallsCount += 1 }
|
|
subscribeToTopLevelJoinedSpacesListenerReceivedListener = listener
|
|
subscribeToTopLevelJoinedSpacesListenerReceivedInvocationsLock.withLock { subscribeToTopLevelJoinedSpacesListenerUnderlyingReceivedInvocations.append(listener) }
|
|
if let subscribeToTopLevelJoinedSpacesListenerClosure = subscribeToTopLevelJoinedSpacesListenerClosure {
|
|
return await subscribeToTopLevelJoinedSpacesListenerClosure(listener)
|
|
} else {
|
|
return subscribeToTopLevelJoinedSpacesListenerReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - topLevelJoinedSpaces
|
|
|
|
private let topLevelJoinedSpacesCallsCountLock = NSLock()
|
|
private var topLevelJoinedSpacesUnderlyingCallsCount = 0
|
|
open var topLevelJoinedSpacesCallsCount: Int {
|
|
get { topLevelJoinedSpacesCallsCountLock.withLock { topLevelJoinedSpacesUnderlyingCallsCount } }
|
|
set { topLevelJoinedSpacesCallsCountLock.withLock { topLevelJoinedSpacesUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var topLevelJoinedSpacesCalled: Bool {
|
|
return topLevelJoinedSpacesCallsCount > 0
|
|
}
|
|
|
|
private let topLevelJoinedSpacesReturnValueLock = NSLock()
|
|
open var topLevelJoinedSpacesUnderlyingReturnValue: [SpaceRoom]!
|
|
open var topLevelJoinedSpacesReturnValue: [SpaceRoom]! {
|
|
get { topLevelJoinedSpacesReturnValueLock.withLock { topLevelJoinedSpacesUnderlyingReturnValue } }
|
|
set { topLevelJoinedSpacesReturnValueLock.withLock { topLevelJoinedSpacesUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var topLevelJoinedSpacesClosure: (() async -> [SpaceRoom])?
|
|
|
|
open override func topLevelJoinedSpaces() async -> [SpaceRoom] {
|
|
topLevelJoinedSpacesCallsCountLock.withLock { topLevelJoinedSpacesUnderlyingCallsCount += 1 }
|
|
if let topLevelJoinedSpacesClosure = topLevelJoinedSpacesClosure {
|
|
return await topLevelJoinedSpacesClosure()
|
|
} else {
|
|
return topLevelJoinedSpacesReturnValue
|
|
}
|
|
}
|
|
}
|
|
open class SpanSDKMock: MatrixRustSDK.Span, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
static func reset()
|
|
{
|
|
}
|
|
|
|
//MARK: - enter
|
|
|
|
private let enterCallsCountLock = NSLock()
|
|
private var enterUnderlyingCallsCount = 0
|
|
open var enterCallsCount: Int {
|
|
get { enterCallsCountLock.withLock { enterUnderlyingCallsCount } }
|
|
set { enterCallsCountLock.withLock { enterUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var enterCalled: Bool {
|
|
return enterCallsCount > 0
|
|
}
|
|
open var enterClosure: (() -> Void)?
|
|
|
|
open override func enter() {
|
|
enterCallsCountLock.withLock { enterUnderlyingCallsCount += 1 }
|
|
enterClosure?()
|
|
}
|
|
|
|
//MARK: - exit
|
|
|
|
private let exitCallsCountLock = NSLock()
|
|
private var exitUnderlyingCallsCount = 0
|
|
open var exitCallsCount: Int {
|
|
get { exitCallsCountLock.withLock { exitUnderlyingCallsCount } }
|
|
set { exitCallsCountLock.withLock { exitUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var exitCalled: Bool {
|
|
return exitCallsCount > 0
|
|
}
|
|
open var exitClosure: (() -> Void)?
|
|
|
|
open override func exit() {
|
|
exitCallsCountLock.withLock { exitUnderlyingCallsCount += 1 }
|
|
exitClosure?()
|
|
}
|
|
|
|
//MARK: - isNone
|
|
|
|
private let isNoneCallsCountLock = NSLock()
|
|
private var isNoneUnderlyingCallsCount = 0
|
|
open var isNoneCallsCount: Int {
|
|
get { isNoneCallsCountLock.withLock { isNoneUnderlyingCallsCount } }
|
|
set { isNoneCallsCountLock.withLock { isNoneUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var isNoneCalled: Bool {
|
|
return isNoneCallsCount > 0
|
|
}
|
|
|
|
private let isNoneReturnValueLock = NSLock()
|
|
open var isNoneUnderlyingReturnValue: Bool!
|
|
open var isNoneReturnValue: Bool! {
|
|
get { isNoneReturnValueLock.withLock { isNoneUnderlyingReturnValue } }
|
|
set { isNoneReturnValueLock.withLock { isNoneUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var isNoneClosure: (() -> Bool)?
|
|
|
|
open override func isNone() -> Bool {
|
|
isNoneCallsCountLock.withLock { isNoneUnderlyingCallsCount += 1 }
|
|
if let isNoneClosure = isNoneClosure {
|
|
return isNoneClosure()
|
|
} else {
|
|
return isNoneReturnValue
|
|
}
|
|
}
|
|
}
|
|
open class SqliteStoreBuilderSDKMock: MatrixRustSDK.SqliteStoreBuilder, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
|
|
//MARK: - cacheSize
|
|
|
|
private let cacheSizeCacheSizeCallsCountLock = NSLock()
|
|
private var cacheSizeCacheSizeUnderlyingCallsCount = 0
|
|
open var cacheSizeCacheSizeCallsCount: Int {
|
|
get { cacheSizeCacheSizeCallsCountLock.withLock { cacheSizeCacheSizeUnderlyingCallsCount } }
|
|
set { cacheSizeCacheSizeCallsCountLock.withLock { cacheSizeCacheSizeUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var cacheSizeCacheSizeCalled: Bool {
|
|
return cacheSizeCacheSizeCallsCount > 0
|
|
}
|
|
private let cacheSizeCacheSizeReceivedCacheSizeLock = NSLock()
|
|
private var cacheSizeCacheSizeUnderlyingReceivedCacheSize: UInt32?
|
|
open var cacheSizeCacheSizeReceivedCacheSize: UInt32? {
|
|
get { cacheSizeCacheSizeReceivedCacheSizeLock.withLock { cacheSizeCacheSizeUnderlyingReceivedCacheSize } }
|
|
set { cacheSizeCacheSizeReceivedCacheSizeLock.withLock { cacheSizeCacheSizeUnderlyingReceivedCacheSize = newValue } }
|
|
}
|
|
private let cacheSizeCacheSizeReceivedInvocationsLock = NSLock()
|
|
private var cacheSizeCacheSizeUnderlyingReceivedInvocations: [UInt32?] = []
|
|
open var cacheSizeCacheSizeReceivedInvocations: [UInt32?] {
|
|
get { cacheSizeCacheSizeReceivedInvocationsLock.withLock { cacheSizeCacheSizeUnderlyingReceivedInvocations } }
|
|
set { cacheSizeCacheSizeReceivedInvocationsLock.withLock { cacheSizeCacheSizeUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let cacheSizeCacheSizeReturnValueLock = NSLock()
|
|
open var cacheSizeCacheSizeUnderlyingReturnValue: SqliteStoreBuilder!
|
|
open var cacheSizeCacheSizeReturnValue: SqliteStoreBuilder! {
|
|
get { cacheSizeCacheSizeReturnValueLock.withLock { cacheSizeCacheSizeUnderlyingReturnValue } }
|
|
set { cacheSizeCacheSizeReturnValueLock.withLock { cacheSizeCacheSizeUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var cacheSizeCacheSizeClosure: ((UInt32?) -> SqliteStoreBuilder)?
|
|
|
|
open override func cacheSize(cacheSize: UInt32?) -> SqliteStoreBuilder {
|
|
cacheSizeCacheSizeCallsCountLock.withLock { cacheSizeCacheSizeUnderlyingCallsCount += 1 }
|
|
cacheSizeCacheSizeReceivedCacheSize = cacheSize
|
|
cacheSizeCacheSizeReceivedInvocationsLock.withLock { cacheSizeCacheSizeUnderlyingReceivedInvocations.append(cacheSize) }
|
|
if let cacheSizeCacheSizeClosure = cacheSizeCacheSizeClosure {
|
|
return cacheSizeCacheSizeClosure(cacheSize)
|
|
} else {
|
|
return cacheSizeCacheSizeReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - journalSizeLimit
|
|
|
|
private let journalSizeLimitLimitCallsCountLock = NSLock()
|
|
private var journalSizeLimitLimitUnderlyingCallsCount = 0
|
|
open var journalSizeLimitLimitCallsCount: Int {
|
|
get { journalSizeLimitLimitCallsCountLock.withLock { journalSizeLimitLimitUnderlyingCallsCount } }
|
|
set { journalSizeLimitLimitCallsCountLock.withLock { journalSizeLimitLimitUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var journalSizeLimitLimitCalled: Bool {
|
|
return journalSizeLimitLimitCallsCount > 0
|
|
}
|
|
private let journalSizeLimitLimitReceivedLimitLock = NSLock()
|
|
private var journalSizeLimitLimitUnderlyingReceivedLimit: UInt32?
|
|
open var journalSizeLimitLimitReceivedLimit: UInt32? {
|
|
get { journalSizeLimitLimitReceivedLimitLock.withLock { journalSizeLimitLimitUnderlyingReceivedLimit } }
|
|
set { journalSizeLimitLimitReceivedLimitLock.withLock { journalSizeLimitLimitUnderlyingReceivedLimit = newValue } }
|
|
}
|
|
private let journalSizeLimitLimitReceivedInvocationsLock = NSLock()
|
|
private var journalSizeLimitLimitUnderlyingReceivedInvocations: [UInt32?] = []
|
|
open var journalSizeLimitLimitReceivedInvocations: [UInt32?] {
|
|
get { journalSizeLimitLimitReceivedInvocationsLock.withLock { journalSizeLimitLimitUnderlyingReceivedInvocations } }
|
|
set { journalSizeLimitLimitReceivedInvocationsLock.withLock { journalSizeLimitLimitUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let journalSizeLimitLimitReturnValueLock = NSLock()
|
|
open var journalSizeLimitLimitUnderlyingReturnValue: SqliteStoreBuilder!
|
|
open var journalSizeLimitLimitReturnValue: SqliteStoreBuilder! {
|
|
get { journalSizeLimitLimitReturnValueLock.withLock { journalSizeLimitLimitUnderlyingReturnValue } }
|
|
set { journalSizeLimitLimitReturnValueLock.withLock { journalSizeLimitLimitUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var journalSizeLimitLimitClosure: ((UInt32?) -> SqliteStoreBuilder)?
|
|
|
|
open override func journalSizeLimit(limit: UInt32?) -> SqliteStoreBuilder {
|
|
journalSizeLimitLimitCallsCountLock.withLock { journalSizeLimitLimitUnderlyingCallsCount += 1 }
|
|
journalSizeLimitLimitReceivedLimit = limit
|
|
journalSizeLimitLimitReceivedInvocationsLock.withLock { journalSizeLimitLimitUnderlyingReceivedInvocations.append(limit) }
|
|
if let journalSizeLimitLimitClosure = journalSizeLimitLimitClosure {
|
|
return journalSizeLimitLimitClosure(limit)
|
|
} else {
|
|
return journalSizeLimitLimitReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - key
|
|
|
|
private let keyKeyCallsCountLock = NSLock()
|
|
private var keyKeyUnderlyingCallsCount = 0
|
|
open var keyKeyCallsCount: Int {
|
|
get { keyKeyCallsCountLock.withLock { keyKeyUnderlyingCallsCount } }
|
|
set { keyKeyCallsCountLock.withLock { keyKeyUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var keyKeyCalled: Bool {
|
|
return keyKeyCallsCount > 0
|
|
}
|
|
private let keyKeyReceivedKeyLock = NSLock()
|
|
private var keyKeyUnderlyingReceivedKey: Data?
|
|
open var keyKeyReceivedKey: Data? {
|
|
get { keyKeyReceivedKeyLock.withLock { keyKeyUnderlyingReceivedKey } }
|
|
set { keyKeyReceivedKeyLock.withLock { keyKeyUnderlyingReceivedKey = newValue } }
|
|
}
|
|
private let keyKeyReceivedInvocationsLock = NSLock()
|
|
private var keyKeyUnderlyingReceivedInvocations: [Data?] = []
|
|
open var keyKeyReceivedInvocations: [Data?] {
|
|
get { keyKeyReceivedInvocationsLock.withLock { keyKeyUnderlyingReceivedInvocations } }
|
|
set { keyKeyReceivedInvocationsLock.withLock { keyKeyUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let keyKeyReturnValueLock = NSLock()
|
|
open var keyKeyUnderlyingReturnValue: SqliteStoreBuilder!
|
|
open var keyKeyReturnValue: SqliteStoreBuilder! {
|
|
get { keyKeyReturnValueLock.withLock { keyKeyUnderlyingReturnValue } }
|
|
set { keyKeyReturnValueLock.withLock { keyKeyUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var keyKeyClosure: ((Data?) -> SqliteStoreBuilder)?
|
|
|
|
open override func key(key: Data?) -> SqliteStoreBuilder {
|
|
keyKeyCallsCountLock.withLock { keyKeyUnderlyingCallsCount += 1 }
|
|
keyKeyReceivedKey = key
|
|
keyKeyReceivedInvocationsLock.withLock { keyKeyUnderlyingReceivedInvocations.append(key) }
|
|
if let keyKeyClosure = keyKeyClosure {
|
|
return keyKeyClosure(key)
|
|
} else {
|
|
return keyKeyReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - passphrase
|
|
|
|
private let passphrasePassphraseCallsCountLock = NSLock()
|
|
private var passphrasePassphraseUnderlyingCallsCount = 0
|
|
open var passphrasePassphraseCallsCount: Int {
|
|
get { passphrasePassphraseCallsCountLock.withLock { passphrasePassphraseUnderlyingCallsCount } }
|
|
set { passphrasePassphraseCallsCountLock.withLock { passphrasePassphraseUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var passphrasePassphraseCalled: Bool {
|
|
return passphrasePassphraseCallsCount > 0
|
|
}
|
|
private let passphrasePassphraseReceivedPassphraseLock = NSLock()
|
|
private var passphrasePassphraseUnderlyingReceivedPassphrase: String?
|
|
open var passphrasePassphraseReceivedPassphrase: String? {
|
|
get { passphrasePassphraseReceivedPassphraseLock.withLock { passphrasePassphraseUnderlyingReceivedPassphrase } }
|
|
set { passphrasePassphraseReceivedPassphraseLock.withLock { passphrasePassphraseUnderlyingReceivedPassphrase = newValue } }
|
|
}
|
|
private let passphrasePassphraseReceivedInvocationsLock = NSLock()
|
|
private var passphrasePassphraseUnderlyingReceivedInvocations: [String?] = []
|
|
open var passphrasePassphraseReceivedInvocations: [String?] {
|
|
get { passphrasePassphraseReceivedInvocationsLock.withLock { passphrasePassphraseUnderlyingReceivedInvocations } }
|
|
set { passphrasePassphraseReceivedInvocationsLock.withLock { passphrasePassphraseUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let passphrasePassphraseReturnValueLock = NSLock()
|
|
open var passphrasePassphraseUnderlyingReturnValue: SqliteStoreBuilder!
|
|
open var passphrasePassphraseReturnValue: SqliteStoreBuilder! {
|
|
get { passphrasePassphraseReturnValueLock.withLock { passphrasePassphraseUnderlyingReturnValue } }
|
|
set { passphrasePassphraseReturnValueLock.withLock { passphrasePassphraseUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var passphrasePassphraseClosure: ((String?) -> SqliteStoreBuilder)?
|
|
|
|
open override func passphrase(passphrase: String?) -> SqliteStoreBuilder {
|
|
passphrasePassphraseCallsCountLock.withLock { passphrasePassphraseUnderlyingCallsCount += 1 }
|
|
passphrasePassphraseReceivedPassphrase = passphrase
|
|
passphrasePassphraseReceivedInvocationsLock.withLock { passphrasePassphraseUnderlyingReceivedInvocations.append(passphrase) }
|
|
if let passphrasePassphraseClosure = passphrasePassphraseClosure {
|
|
return passphrasePassphraseClosure(passphrase)
|
|
} else {
|
|
return passphrasePassphraseReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - poolMaxSize
|
|
|
|
private let poolMaxSizePoolMaxSizeCallsCountLock = NSLock()
|
|
private var poolMaxSizePoolMaxSizeUnderlyingCallsCount = 0
|
|
open var poolMaxSizePoolMaxSizeCallsCount: Int {
|
|
get { poolMaxSizePoolMaxSizeCallsCountLock.withLock { poolMaxSizePoolMaxSizeUnderlyingCallsCount } }
|
|
set { poolMaxSizePoolMaxSizeCallsCountLock.withLock { poolMaxSizePoolMaxSizeUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var poolMaxSizePoolMaxSizeCalled: Bool {
|
|
return poolMaxSizePoolMaxSizeCallsCount > 0
|
|
}
|
|
private let poolMaxSizePoolMaxSizeReceivedPoolMaxSizeLock = NSLock()
|
|
private var poolMaxSizePoolMaxSizeUnderlyingReceivedPoolMaxSize: UInt32?
|
|
open var poolMaxSizePoolMaxSizeReceivedPoolMaxSize: UInt32? {
|
|
get { poolMaxSizePoolMaxSizeReceivedPoolMaxSizeLock.withLock { poolMaxSizePoolMaxSizeUnderlyingReceivedPoolMaxSize } }
|
|
set { poolMaxSizePoolMaxSizeReceivedPoolMaxSizeLock.withLock { poolMaxSizePoolMaxSizeUnderlyingReceivedPoolMaxSize = newValue } }
|
|
}
|
|
private let poolMaxSizePoolMaxSizeReceivedInvocationsLock = NSLock()
|
|
private var poolMaxSizePoolMaxSizeUnderlyingReceivedInvocations: [UInt32?] = []
|
|
open var poolMaxSizePoolMaxSizeReceivedInvocations: [UInt32?] {
|
|
get { poolMaxSizePoolMaxSizeReceivedInvocationsLock.withLock { poolMaxSizePoolMaxSizeUnderlyingReceivedInvocations } }
|
|
set { poolMaxSizePoolMaxSizeReceivedInvocationsLock.withLock { poolMaxSizePoolMaxSizeUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let poolMaxSizePoolMaxSizeReturnValueLock = NSLock()
|
|
open var poolMaxSizePoolMaxSizeUnderlyingReturnValue: SqliteStoreBuilder!
|
|
open var poolMaxSizePoolMaxSizeReturnValue: SqliteStoreBuilder! {
|
|
get { poolMaxSizePoolMaxSizeReturnValueLock.withLock { poolMaxSizePoolMaxSizeUnderlyingReturnValue } }
|
|
set { poolMaxSizePoolMaxSizeReturnValueLock.withLock { poolMaxSizePoolMaxSizeUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var poolMaxSizePoolMaxSizeClosure: ((UInt32?) -> SqliteStoreBuilder)?
|
|
|
|
open override func poolMaxSize(poolMaxSize: UInt32?) -> SqliteStoreBuilder {
|
|
poolMaxSizePoolMaxSizeCallsCountLock.withLock { poolMaxSizePoolMaxSizeUnderlyingCallsCount += 1 }
|
|
poolMaxSizePoolMaxSizeReceivedPoolMaxSize = poolMaxSize
|
|
poolMaxSizePoolMaxSizeReceivedInvocationsLock.withLock { poolMaxSizePoolMaxSizeUnderlyingReceivedInvocations.append(poolMaxSize) }
|
|
if let poolMaxSizePoolMaxSizeClosure = poolMaxSizePoolMaxSizeClosure {
|
|
return poolMaxSizePoolMaxSizeClosure(poolMaxSize)
|
|
} else {
|
|
return poolMaxSizePoolMaxSizeReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - systemIsMemoryConstrained
|
|
|
|
private let systemIsMemoryConstrainedCallsCountLock = NSLock()
|
|
private var systemIsMemoryConstrainedUnderlyingCallsCount = 0
|
|
open var systemIsMemoryConstrainedCallsCount: Int {
|
|
get { systemIsMemoryConstrainedCallsCountLock.withLock { systemIsMemoryConstrainedUnderlyingCallsCount } }
|
|
set { systemIsMemoryConstrainedCallsCountLock.withLock { systemIsMemoryConstrainedUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var systemIsMemoryConstrainedCalled: Bool {
|
|
return systemIsMemoryConstrainedCallsCount > 0
|
|
}
|
|
|
|
private let systemIsMemoryConstrainedReturnValueLock = NSLock()
|
|
open var systemIsMemoryConstrainedUnderlyingReturnValue: SqliteStoreBuilder!
|
|
open var systemIsMemoryConstrainedReturnValue: SqliteStoreBuilder! {
|
|
get { systemIsMemoryConstrainedReturnValueLock.withLock { systemIsMemoryConstrainedUnderlyingReturnValue } }
|
|
set { systemIsMemoryConstrainedReturnValueLock.withLock { systemIsMemoryConstrainedUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var systemIsMemoryConstrainedClosure: (() -> SqliteStoreBuilder)?
|
|
|
|
open override func systemIsMemoryConstrained() -> SqliteStoreBuilder {
|
|
systemIsMemoryConstrainedCallsCountLock.withLock { systemIsMemoryConstrainedUnderlyingCallsCount += 1 }
|
|
if let systemIsMemoryConstrainedClosure = systemIsMemoryConstrainedClosure {
|
|
return systemIsMemoryConstrainedClosure()
|
|
} else {
|
|
return systemIsMemoryConstrainedReturnValue
|
|
}
|
|
}
|
|
}
|
|
open class SsoHandlerSDKMock: MatrixRustSDK.SsoHandler, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
|
|
//MARK: - finish
|
|
|
|
open var finishCallbackUrlThrowableError: Error?
|
|
private let finishCallbackUrlCallsCountLock = NSLock()
|
|
private var finishCallbackUrlUnderlyingCallsCount = 0
|
|
open var finishCallbackUrlCallsCount: Int {
|
|
get { finishCallbackUrlCallsCountLock.withLock { finishCallbackUrlUnderlyingCallsCount } }
|
|
set { finishCallbackUrlCallsCountLock.withLock { finishCallbackUrlUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var finishCallbackUrlCalled: Bool {
|
|
return finishCallbackUrlCallsCount > 0
|
|
}
|
|
private let finishCallbackUrlReceivedCallbackUrlLock = NSLock()
|
|
private var finishCallbackUrlUnderlyingReceivedCallbackUrl: String?
|
|
open var finishCallbackUrlReceivedCallbackUrl: String? {
|
|
get { finishCallbackUrlReceivedCallbackUrlLock.withLock { finishCallbackUrlUnderlyingReceivedCallbackUrl } }
|
|
set { finishCallbackUrlReceivedCallbackUrlLock.withLock { finishCallbackUrlUnderlyingReceivedCallbackUrl = newValue } }
|
|
}
|
|
private let finishCallbackUrlReceivedInvocationsLock = NSLock()
|
|
private var finishCallbackUrlUnderlyingReceivedInvocations: [String] = []
|
|
open var finishCallbackUrlReceivedInvocations: [String] {
|
|
get { finishCallbackUrlReceivedInvocationsLock.withLock { finishCallbackUrlUnderlyingReceivedInvocations } }
|
|
set { finishCallbackUrlReceivedInvocationsLock.withLock { finishCallbackUrlUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var finishCallbackUrlClosure: ((String) async throws -> Void)?
|
|
|
|
open override func finish(callbackUrl: String) async throws {
|
|
if let error = finishCallbackUrlThrowableError {
|
|
throw error
|
|
}
|
|
finishCallbackUrlCallsCountLock.withLock { finishCallbackUrlUnderlyingCallsCount += 1 }
|
|
finishCallbackUrlReceivedCallbackUrl = callbackUrl
|
|
finishCallbackUrlReceivedInvocationsLock.withLock { finishCallbackUrlUnderlyingReceivedInvocations.append(callbackUrl) }
|
|
try await finishCallbackUrlClosure?(callbackUrl)
|
|
}
|
|
|
|
//MARK: - url
|
|
|
|
private let urlCallsCountLock = NSLock()
|
|
private var urlUnderlyingCallsCount = 0
|
|
open var urlCallsCount: Int {
|
|
get { urlCallsCountLock.withLock { urlUnderlyingCallsCount } }
|
|
set { urlCallsCountLock.withLock { urlUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var urlCalled: Bool {
|
|
return urlCallsCount > 0
|
|
}
|
|
|
|
private let urlReturnValueLock = NSLock()
|
|
open var urlUnderlyingReturnValue: String!
|
|
open var urlReturnValue: String! {
|
|
get { urlReturnValueLock.withLock { urlUnderlyingReturnValue } }
|
|
set { urlReturnValueLock.withLock { urlUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var urlClosure: (() -> String)?
|
|
|
|
open override func url() -> String {
|
|
urlCallsCountLock.withLock { urlUnderlyingCallsCount += 1 }
|
|
if let urlClosure = urlClosure {
|
|
return urlClosure()
|
|
} else {
|
|
return urlReturnValue
|
|
}
|
|
}
|
|
}
|
|
open class SyncServiceSDKMock: MatrixRustSDK.SyncService, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
|
|
//MARK: - expireSessions
|
|
|
|
private let expireSessionsCallsCountLock = NSLock()
|
|
private var expireSessionsUnderlyingCallsCount = 0
|
|
open var expireSessionsCallsCount: Int {
|
|
get { expireSessionsCallsCountLock.withLock { expireSessionsUnderlyingCallsCount } }
|
|
set { expireSessionsCallsCountLock.withLock { expireSessionsUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var expireSessionsCalled: Bool {
|
|
return expireSessionsCallsCount > 0
|
|
}
|
|
open var expireSessionsClosure: (() async -> Void)?
|
|
|
|
open override func expireSessions() async {
|
|
expireSessionsCallsCountLock.withLock { expireSessionsUnderlyingCallsCount += 1 }
|
|
await expireSessionsClosure?()
|
|
}
|
|
|
|
//MARK: - roomListService
|
|
|
|
private let roomListServiceCallsCountLock = NSLock()
|
|
private var roomListServiceUnderlyingCallsCount = 0
|
|
open var roomListServiceCallsCount: Int {
|
|
get { roomListServiceCallsCountLock.withLock { roomListServiceUnderlyingCallsCount } }
|
|
set { roomListServiceCallsCountLock.withLock { roomListServiceUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var roomListServiceCalled: Bool {
|
|
return roomListServiceCallsCount > 0
|
|
}
|
|
|
|
private let roomListServiceReturnValueLock = NSLock()
|
|
open var roomListServiceUnderlyingReturnValue: RoomListService!
|
|
open var roomListServiceReturnValue: RoomListService! {
|
|
get { roomListServiceReturnValueLock.withLock { roomListServiceUnderlyingReturnValue } }
|
|
set { roomListServiceReturnValueLock.withLock { roomListServiceUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var roomListServiceClosure: (() -> RoomListService)?
|
|
|
|
open override func roomListService() -> RoomListService {
|
|
roomListServiceCallsCountLock.withLock { roomListServiceUnderlyingCallsCount += 1 }
|
|
if let roomListServiceClosure = roomListServiceClosure {
|
|
return roomListServiceClosure()
|
|
} else {
|
|
return roomListServiceReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - start
|
|
|
|
private let startCallsCountLock = NSLock()
|
|
private var startUnderlyingCallsCount = 0
|
|
open var startCallsCount: Int {
|
|
get { startCallsCountLock.withLock { startUnderlyingCallsCount } }
|
|
set { startCallsCountLock.withLock { startUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var startCalled: Bool {
|
|
return startCallsCount > 0
|
|
}
|
|
open var startClosure: (() async -> Void)?
|
|
|
|
open override func start() async {
|
|
startCallsCountLock.withLock { startUnderlyingCallsCount += 1 }
|
|
await startClosure?()
|
|
}
|
|
|
|
//MARK: - state
|
|
|
|
private let stateListenerCallsCountLock = NSLock()
|
|
private var stateListenerUnderlyingCallsCount = 0
|
|
open var stateListenerCallsCount: Int {
|
|
get { stateListenerCallsCountLock.withLock { stateListenerUnderlyingCallsCount } }
|
|
set { stateListenerCallsCountLock.withLock { stateListenerUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var stateListenerCalled: Bool {
|
|
return stateListenerCallsCount > 0
|
|
}
|
|
private let stateListenerReceivedListenerLock = NSLock()
|
|
private var stateListenerUnderlyingReceivedListener: SyncServiceStateObserver?
|
|
open var stateListenerReceivedListener: SyncServiceStateObserver? {
|
|
get { stateListenerReceivedListenerLock.withLock { stateListenerUnderlyingReceivedListener } }
|
|
set { stateListenerReceivedListenerLock.withLock { stateListenerUnderlyingReceivedListener = newValue } }
|
|
}
|
|
private let stateListenerReceivedInvocationsLock = NSLock()
|
|
private var stateListenerUnderlyingReceivedInvocations: [SyncServiceStateObserver] = []
|
|
open var stateListenerReceivedInvocations: [SyncServiceStateObserver] {
|
|
get { stateListenerReceivedInvocationsLock.withLock { stateListenerUnderlyingReceivedInvocations } }
|
|
set { stateListenerReceivedInvocationsLock.withLock { stateListenerUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let stateListenerReturnValueLock = NSLock()
|
|
open var stateListenerUnderlyingReturnValue: TaskHandle!
|
|
open var stateListenerReturnValue: TaskHandle! {
|
|
get { stateListenerReturnValueLock.withLock { stateListenerUnderlyingReturnValue } }
|
|
set { stateListenerReturnValueLock.withLock { stateListenerUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var stateListenerClosure: ((SyncServiceStateObserver) -> TaskHandle)?
|
|
|
|
open override func state(listener: SyncServiceStateObserver) -> TaskHandle {
|
|
stateListenerCallsCountLock.withLock { stateListenerUnderlyingCallsCount += 1 }
|
|
stateListenerReceivedListener = listener
|
|
stateListenerReceivedInvocationsLock.withLock { stateListenerUnderlyingReceivedInvocations.append(listener) }
|
|
if let stateListenerClosure = stateListenerClosure {
|
|
return stateListenerClosure(listener)
|
|
} else {
|
|
return stateListenerReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - stop
|
|
|
|
private let stopCallsCountLock = NSLock()
|
|
private var stopUnderlyingCallsCount = 0
|
|
open var stopCallsCount: Int {
|
|
get { stopCallsCountLock.withLock { stopUnderlyingCallsCount } }
|
|
set { stopCallsCountLock.withLock { stopUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var stopCalled: Bool {
|
|
return stopCallsCount > 0
|
|
}
|
|
open var stopClosure: (() async -> Void)?
|
|
|
|
open override func stop() async {
|
|
stopCallsCountLock.withLock { stopUnderlyingCallsCount += 1 }
|
|
await stopClosure?()
|
|
}
|
|
}
|
|
open class SyncServiceBuilderSDKMock: MatrixRustSDK.SyncServiceBuilder, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
|
|
//MARK: - finish
|
|
|
|
open var finishThrowableError: Error?
|
|
private let finishCallsCountLock = NSLock()
|
|
private var finishUnderlyingCallsCount = 0
|
|
open var finishCallsCount: Int {
|
|
get { finishCallsCountLock.withLock { finishUnderlyingCallsCount } }
|
|
set { finishCallsCountLock.withLock { finishUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var finishCalled: Bool {
|
|
return finishCallsCount > 0
|
|
}
|
|
|
|
private let finishReturnValueLock = NSLock()
|
|
open var finishUnderlyingReturnValue: SyncService!
|
|
open var finishReturnValue: SyncService! {
|
|
get { finishReturnValueLock.withLock { finishUnderlyingReturnValue } }
|
|
set { finishReturnValueLock.withLock { finishUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var finishClosure: (() async throws -> SyncService)?
|
|
|
|
open override func finish() async throws -> SyncService {
|
|
if let error = finishThrowableError {
|
|
throw error
|
|
}
|
|
finishCallsCountLock.withLock { finishUnderlyingCallsCount += 1 }
|
|
if let finishClosure = finishClosure {
|
|
return try await finishClosure()
|
|
} else {
|
|
return finishReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - withOfflineMode
|
|
|
|
private let withOfflineModeCallsCountLock = NSLock()
|
|
private var withOfflineModeUnderlyingCallsCount = 0
|
|
open var withOfflineModeCallsCount: Int {
|
|
get { withOfflineModeCallsCountLock.withLock { withOfflineModeUnderlyingCallsCount } }
|
|
set { withOfflineModeCallsCountLock.withLock { withOfflineModeUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var withOfflineModeCalled: Bool {
|
|
return withOfflineModeCallsCount > 0
|
|
}
|
|
|
|
private let withOfflineModeReturnValueLock = NSLock()
|
|
open var withOfflineModeUnderlyingReturnValue: SyncServiceBuilder!
|
|
open var withOfflineModeReturnValue: SyncServiceBuilder! {
|
|
get { withOfflineModeReturnValueLock.withLock { withOfflineModeUnderlyingReturnValue } }
|
|
set { withOfflineModeReturnValueLock.withLock { withOfflineModeUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var withOfflineModeClosure: (() -> SyncServiceBuilder)?
|
|
|
|
open override func withOfflineMode() -> SyncServiceBuilder {
|
|
withOfflineModeCallsCountLock.withLock { withOfflineModeUnderlyingCallsCount += 1 }
|
|
if let withOfflineModeClosure = withOfflineModeClosure {
|
|
return withOfflineModeClosure()
|
|
} else {
|
|
return withOfflineModeReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - withRoomListConnectionId
|
|
|
|
private let withRoomListConnectionIdConnectionIdCallsCountLock = NSLock()
|
|
private var withRoomListConnectionIdConnectionIdUnderlyingCallsCount = 0
|
|
open var withRoomListConnectionIdConnectionIdCallsCount: Int {
|
|
get { withRoomListConnectionIdConnectionIdCallsCountLock.withLock { withRoomListConnectionIdConnectionIdUnderlyingCallsCount } }
|
|
set { withRoomListConnectionIdConnectionIdCallsCountLock.withLock { withRoomListConnectionIdConnectionIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var withRoomListConnectionIdConnectionIdCalled: Bool {
|
|
return withRoomListConnectionIdConnectionIdCallsCount > 0
|
|
}
|
|
private let withRoomListConnectionIdConnectionIdReceivedConnectionIdLock = NSLock()
|
|
private var withRoomListConnectionIdConnectionIdUnderlyingReceivedConnectionId: String?
|
|
open var withRoomListConnectionIdConnectionIdReceivedConnectionId: String? {
|
|
get { withRoomListConnectionIdConnectionIdReceivedConnectionIdLock.withLock { withRoomListConnectionIdConnectionIdUnderlyingReceivedConnectionId } }
|
|
set { withRoomListConnectionIdConnectionIdReceivedConnectionIdLock.withLock { withRoomListConnectionIdConnectionIdUnderlyingReceivedConnectionId = newValue } }
|
|
}
|
|
private let withRoomListConnectionIdConnectionIdReceivedInvocationsLock = NSLock()
|
|
private var withRoomListConnectionIdConnectionIdUnderlyingReceivedInvocations: [String] = []
|
|
open var withRoomListConnectionIdConnectionIdReceivedInvocations: [String] {
|
|
get { withRoomListConnectionIdConnectionIdReceivedInvocationsLock.withLock { withRoomListConnectionIdConnectionIdUnderlyingReceivedInvocations } }
|
|
set { withRoomListConnectionIdConnectionIdReceivedInvocationsLock.withLock { withRoomListConnectionIdConnectionIdUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let withRoomListConnectionIdConnectionIdReturnValueLock = NSLock()
|
|
open var withRoomListConnectionIdConnectionIdUnderlyingReturnValue: SyncServiceBuilder!
|
|
open var withRoomListConnectionIdConnectionIdReturnValue: SyncServiceBuilder! {
|
|
get { withRoomListConnectionIdConnectionIdReturnValueLock.withLock { withRoomListConnectionIdConnectionIdUnderlyingReturnValue } }
|
|
set { withRoomListConnectionIdConnectionIdReturnValueLock.withLock { withRoomListConnectionIdConnectionIdUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var withRoomListConnectionIdConnectionIdClosure: ((String) -> SyncServiceBuilder)?
|
|
|
|
open override func withRoomListConnectionId(connectionId: String) -> SyncServiceBuilder {
|
|
withRoomListConnectionIdConnectionIdCallsCountLock.withLock { withRoomListConnectionIdConnectionIdUnderlyingCallsCount += 1 }
|
|
withRoomListConnectionIdConnectionIdReceivedConnectionId = connectionId
|
|
withRoomListConnectionIdConnectionIdReceivedInvocationsLock.withLock { withRoomListConnectionIdConnectionIdUnderlyingReceivedInvocations.append(connectionId) }
|
|
if let withRoomListConnectionIdConnectionIdClosure = withRoomListConnectionIdConnectionIdClosure {
|
|
return withRoomListConnectionIdConnectionIdClosure(connectionId)
|
|
} else {
|
|
return withRoomListConnectionIdConnectionIdReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - withRoomListTimelineLimit
|
|
|
|
private let withRoomListTimelineLimitLimitCallsCountLock = NSLock()
|
|
private var withRoomListTimelineLimitLimitUnderlyingCallsCount = 0
|
|
open var withRoomListTimelineLimitLimitCallsCount: Int {
|
|
get { withRoomListTimelineLimitLimitCallsCountLock.withLock { withRoomListTimelineLimitLimitUnderlyingCallsCount } }
|
|
set { withRoomListTimelineLimitLimitCallsCountLock.withLock { withRoomListTimelineLimitLimitUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var withRoomListTimelineLimitLimitCalled: Bool {
|
|
return withRoomListTimelineLimitLimitCallsCount > 0
|
|
}
|
|
private let withRoomListTimelineLimitLimitReceivedLimitLock = NSLock()
|
|
private var withRoomListTimelineLimitLimitUnderlyingReceivedLimit: UInt32?
|
|
open var withRoomListTimelineLimitLimitReceivedLimit: UInt32? {
|
|
get { withRoomListTimelineLimitLimitReceivedLimitLock.withLock { withRoomListTimelineLimitLimitUnderlyingReceivedLimit } }
|
|
set { withRoomListTimelineLimitLimitReceivedLimitLock.withLock { withRoomListTimelineLimitLimitUnderlyingReceivedLimit = newValue } }
|
|
}
|
|
private let withRoomListTimelineLimitLimitReceivedInvocationsLock = NSLock()
|
|
private var withRoomListTimelineLimitLimitUnderlyingReceivedInvocations: [UInt32] = []
|
|
open var withRoomListTimelineLimitLimitReceivedInvocations: [UInt32] {
|
|
get { withRoomListTimelineLimitLimitReceivedInvocationsLock.withLock { withRoomListTimelineLimitLimitUnderlyingReceivedInvocations } }
|
|
set { withRoomListTimelineLimitLimitReceivedInvocationsLock.withLock { withRoomListTimelineLimitLimitUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let withRoomListTimelineLimitLimitReturnValueLock = NSLock()
|
|
open var withRoomListTimelineLimitLimitUnderlyingReturnValue: SyncServiceBuilder!
|
|
open var withRoomListTimelineLimitLimitReturnValue: SyncServiceBuilder! {
|
|
get { withRoomListTimelineLimitLimitReturnValueLock.withLock { withRoomListTimelineLimitLimitUnderlyingReturnValue } }
|
|
set { withRoomListTimelineLimitLimitReturnValueLock.withLock { withRoomListTimelineLimitLimitUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var withRoomListTimelineLimitLimitClosure: ((UInt32) -> SyncServiceBuilder)?
|
|
|
|
open override func withRoomListTimelineLimit(limit: UInt32) -> SyncServiceBuilder {
|
|
withRoomListTimelineLimitLimitCallsCountLock.withLock { withRoomListTimelineLimitLimitUnderlyingCallsCount += 1 }
|
|
withRoomListTimelineLimitLimitReceivedLimit = limit
|
|
withRoomListTimelineLimitLimitReceivedInvocationsLock.withLock { withRoomListTimelineLimitLimitUnderlyingReceivedInvocations.append(limit) }
|
|
if let withRoomListTimelineLimitLimitClosure = withRoomListTimelineLimitLimitClosure {
|
|
return withRoomListTimelineLimitLimitClosure(limit)
|
|
} else {
|
|
return withRoomListTimelineLimitLimitReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - withSharePos
|
|
|
|
private let withSharePosEnableCallsCountLock = NSLock()
|
|
private var withSharePosEnableUnderlyingCallsCount = 0
|
|
open var withSharePosEnableCallsCount: Int {
|
|
get { withSharePosEnableCallsCountLock.withLock { withSharePosEnableUnderlyingCallsCount } }
|
|
set { withSharePosEnableCallsCountLock.withLock { withSharePosEnableUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var withSharePosEnableCalled: Bool {
|
|
return withSharePosEnableCallsCount > 0
|
|
}
|
|
private let withSharePosEnableReceivedEnableLock = NSLock()
|
|
private var withSharePosEnableUnderlyingReceivedEnable: Bool?
|
|
open var withSharePosEnableReceivedEnable: Bool? {
|
|
get { withSharePosEnableReceivedEnableLock.withLock { withSharePosEnableUnderlyingReceivedEnable } }
|
|
set { withSharePosEnableReceivedEnableLock.withLock { withSharePosEnableUnderlyingReceivedEnable = newValue } }
|
|
}
|
|
private let withSharePosEnableReceivedInvocationsLock = NSLock()
|
|
private var withSharePosEnableUnderlyingReceivedInvocations: [Bool] = []
|
|
open var withSharePosEnableReceivedInvocations: [Bool] {
|
|
get { withSharePosEnableReceivedInvocationsLock.withLock { withSharePosEnableUnderlyingReceivedInvocations } }
|
|
set { withSharePosEnableReceivedInvocationsLock.withLock { withSharePosEnableUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let withSharePosEnableReturnValueLock = NSLock()
|
|
open var withSharePosEnableUnderlyingReturnValue: SyncServiceBuilder!
|
|
open var withSharePosEnableReturnValue: SyncServiceBuilder! {
|
|
get { withSharePosEnableReturnValueLock.withLock { withSharePosEnableUnderlyingReturnValue } }
|
|
set { withSharePosEnableReturnValueLock.withLock { withSharePosEnableUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var withSharePosEnableClosure: ((Bool) -> SyncServiceBuilder)?
|
|
|
|
open override func withSharePos(enable: Bool) -> SyncServiceBuilder {
|
|
withSharePosEnableCallsCountLock.withLock { withSharePosEnableUnderlyingCallsCount += 1 }
|
|
withSharePosEnableReceivedEnable = enable
|
|
withSharePosEnableReceivedInvocationsLock.withLock { withSharePosEnableUnderlyingReceivedInvocations.append(enable) }
|
|
if let withSharePosEnableClosure = withSharePosEnableClosure {
|
|
return withSharePosEnableClosure(enable)
|
|
} else {
|
|
return withSharePosEnableReturnValue
|
|
}
|
|
}
|
|
}
|
|
open class TaskHandleSDKMock: MatrixRustSDK.TaskHandle, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
|
|
//MARK: - cancel
|
|
|
|
private let cancelCallsCountLock = NSLock()
|
|
private var cancelUnderlyingCallsCount = 0
|
|
open var cancelCallsCount: Int {
|
|
get { cancelCallsCountLock.withLock { cancelUnderlyingCallsCount } }
|
|
set { cancelCallsCountLock.withLock { cancelUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var cancelCalled: Bool {
|
|
return cancelCallsCount > 0
|
|
}
|
|
open var cancelClosure: (() -> Void)?
|
|
|
|
open override func cancel() {
|
|
cancelCallsCountLock.withLock { cancelUnderlyingCallsCount += 1 }
|
|
cancelClosure?()
|
|
}
|
|
|
|
//MARK: - isFinished
|
|
|
|
private let isFinishedCallsCountLock = NSLock()
|
|
private var isFinishedUnderlyingCallsCount = 0
|
|
open var isFinishedCallsCount: Int {
|
|
get { isFinishedCallsCountLock.withLock { isFinishedUnderlyingCallsCount } }
|
|
set { isFinishedCallsCountLock.withLock { isFinishedUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var isFinishedCalled: Bool {
|
|
return isFinishedCallsCount > 0
|
|
}
|
|
|
|
private let isFinishedReturnValueLock = NSLock()
|
|
open var isFinishedUnderlyingReturnValue: Bool!
|
|
open var isFinishedReturnValue: Bool! {
|
|
get { isFinishedReturnValueLock.withLock { isFinishedUnderlyingReturnValue } }
|
|
set { isFinishedReturnValueLock.withLock { isFinishedUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var isFinishedClosure: (() -> Bool)?
|
|
|
|
open override func isFinished() -> Bool {
|
|
isFinishedCallsCountLock.withLock { isFinishedUnderlyingCallsCount += 1 }
|
|
if let isFinishedClosure = isFinishedClosure {
|
|
return isFinishedClosure()
|
|
} else {
|
|
return isFinishedReturnValue
|
|
}
|
|
}
|
|
}
|
|
open class ThreadListServiceSDKMock: MatrixRustSDK.ThreadListService, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
|
|
//MARK: - items
|
|
|
|
private let itemsCallsCountLock = NSLock()
|
|
private var itemsUnderlyingCallsCount = 0
|
|
open var itemsCallsCount: Int {
|
|
get { itemsCallsCountLock.withLock { itemsUnderlyingCallsCount } }
|
|
set { itemsCallsCountLock.withLock { itemsUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var itemsCalled: Bool {
|
|
return itemsCallsCount > 0
|
|
}
|
|
|
|
private let itemsReturnValueLock = NSLock()
|
|
open var itemsUnderlyingReturnValue: [ThreadListItem]!
|
|
open var itemsReturnValue: [ThreadListItem]! {
|
|
get { itemsReturnValueLock.withLock { itemsUnderlyingReturnValue } }
|
|
set { itemsReturnValueLock.withLock { itemsUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var itemsClosure: (() -> [ThreadListItem])?
|
|
|
|
open override func items() -> [ThreadListItem] {
|
|
itemsCallsCountLock.withLock { itemsUnderlyingCallsCount += 1 }
|
|
if let itemsClosure = itemsClosure {
|
|
return itemsClosure()
|
|
} else {
|
|
return itemsReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - paginate
|
|
|
|
open var paginateThrowableError: Error?
|
|
private let paginateCallsCountLock = NSLock()
|
|
private var paginateUnderlyingCallsCount = 0
|
|
open var paginateCallsCount: Int {
|
|
get { paginateCallsCountLock.withLock { paginateUnderlyingCallsCount } }
|
|
set { paginateCallsCountLock.withLock { paginateUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var paginateCalled: Bool {
|
|
return paginateCallsCount > 0
|
|
}
|
|
open var paginateClosure: (() async throws -> Void)?
|
|
|
|
open override func paginate() async throws {
|
|
if let error = paginateThrowableError {
|
|
throw error
|
|
}
|
|
paginateCallsCountLock.withLock { paginateUnderlyingCallsCount += 1 }
|
|
try await paginateClosure?()
|
|
}
|
|
|
|
//MARK: - paginationState
|
|
|
|
private let paginationStateCallsCountLock = NSLock()
|
|
private var paginationStateUnderlyingCallsCount = 0
|
|
open var paginationStateCallsCount: Int {
|
|
get { paginationStateCallsCountLock.withLock { paginationStateUnderlyingCallsCount } }
|
|
set { paginationStateCallsCountLock.withLock { paginationStateUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var paginationStateCalled: Bool {
|
|
return paginationStateCallsCount > 0
|
|
}
|
|
|
|
private let paginationStateReturnValueLock = NSLock()
|
|
open var paginationStateUnderlyingReturnValue: ThreadListPaginationState!
|
|
open var paginationStateReturnValue: ThreadListPaginationState! {
|
|
get { paginationStateReturnValueLock.withLock { paginationStateUnderlyingReturnValue } }
|
|
set { paginationStateReturnValueLock.withLock { paginationStateUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var paginationStateClosure: (() -> ThreadListPaginationState)?
|
|
|
|
open override func paginationState() -> ThreadListPaginationState {
|
|
paginationStateCallsCountLock.withLock { paginationStateUnderlyingCallsCount += 1 }
|
|
if let paginationStateClosure = paginationStateClosure {
|
|
return paginationStateClosure()
|
|
} else {
|
|
return paginationStateReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - reset
|
|
|
|
private let resetCallsCountLock = NSLock()
|
|
private var resetUnderlyingCallsCount = 0
|
|
open var resetCallsCount: Int {
|
|
get { resetCallsCountLock.withLock { resetUnderlyingCallsCount } }
|
|
set { resetCallsCountLock.withLock { resetUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var resetCalled: Bool {
|
|
return resetCallsCount > 0
|
|
}
|
|
open var resetClosure: (() async -> Void)?
|
|
|
|
open override func reset() async {
|
|
resetCallsCountLock.withLock { resetUnderlyingCallsCount += 1 }
|
|
await resetClosure?()
|
|
}
|
|
|
|
//MARK: - subscribeToItemsUpdates
|
|
|
|
private let subscribeToItemsUpdatesListenerCallsCountLock = NSLock()
|
|
private var subscribeToItemsUpdatesListenerUnderlyingCallsCount = 0
|
|
open var subscribeToItemsUpdatesListenerCallsCount: Int {
|
|
get { subscribeToItemsUpdatesListenerCallsCountLock.withLock { subscribeToItemsUpdatesListenerUnderlyingCallsCount } }
|
|
set { subscribeToItemsUpdatesListenerCallsCountLock.withLock { subscribeToItemsUpdatesListenerUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var subscribeToItemsUpdatesListenerCalled: Bool {
|
|
return subscribeToItemsUpdatesListenerCallsCount > 0
|
|
}
|
|
private let subscribeToItemsUpdatesListenerReceivedListenerLock = NSLock()
|
|
private var subscribeToItemsUpdatesListenerUnderlyingReceivedListener: ThreadListEntriesListener?
|
|
open var subscribeToItemsUpdatesListenerReceivedListener: ThreadListEntriesListener? {
|
|
get { subscribeToItemsUpdatesListenerReceivedListenerLock.withLock { subscribeToItemsUpdatesListenerUnderlyingReceivedListener } }
|
|
set { subscribeToItemsUpdatesListenerReceivedListenerLock.withLock { subscribeToItemsUpdatesListenerUnderlyingReceivedListener = newValue } }
|
|
}
|
|
private let subscribeToItemsUpdatesListenerReceivedInvocationsLock = NSLock()
|
|
private var subscribeToItemsUpdatesListenerUnderlyingReceivedInvocations: [ThreadListEntriesListener] = []
|
|
open var subscribeToItemsUpdatesListenerReceivedInvocations: [ThreadListEntriesListener] {
|
|
get { subscribeToItemsUpdatesListenerReceivedInvocationsLock.withLock { subscribeToItemsUpdatesListenerUnderlyingReceivedInvocations } }
|
|
set { subscribeToItemsUpdatesListenerReceivedInvocationsLock.withLock { subscribeToItemsUpdatesListenerUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let subscribeToItemsUpdatesListenerReturnValueLock = NSLock()
|
|
open var subscribeToItemsUpdatesListenerUnderlyingReturnValue: TaskHandle!
|
|
open var subscribeToItemsUpdatesListenerReturnValue: TaskHandle! {
|
|
get { subscribeToItemsUpdatesListenerReturnValueLock.withLock { subscribeToItemsUpdatesListenerUnderlyingReturnValue } }
|
|
set { subscribeToItemsUpdatesListenerReturnValueLock.withLock { subscribeToItemsUpdatesListenerUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var subscribeToItemsUpdatesListenerClosure: ((ThreadListEntriesListener) -> TaskHandle)?
|
|
|
|
open override func subscribeToItemsUpdates(listener: ThreadListEntriesListener) -> TaskHandle {
|
|
subscribeToItemsUpdatesListenerCallsCountLock.withLock { subscribeToItemsUpdatesListenerUnderlyingCallsCount += 1 }
|
|
subscribeToItemsUpdatesListenerReceivedListener = listener
|
|
subscribeToItemsUpdatesListenerReceivedInvocationsLock.withLock { subscribeToItemsUpdatesListenerUnderlyingReceivedInvocations.append(listener) }
|
|
if let subscribeToItemsUpdatesListenerClosure = subscribeToItemsUpdatesListenerClosure {
|
|
return subscribeToItemsUpdatesListenerClosure(listener)
|
|
} else {
|
|
return subscribeToItemsUpdatesListenerReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - subscribeToPaginationStateUpdates
|
|
|
|
private let subscribeToPaginationStateUpdatesListenerCallsCountLock = NSLock()
|
|
private var subscribeToPaginationStateUpdatesListenerUnderlyingCallsCount = 0
|
|
open var subscribeToPaginationStateUpdatesListenerCallsCount: Int {
|
|
get { subscribeToPaginationStateUpdatesListenerCallsCountLock.withLock { subscribeToPaginationStateUpdatesListenerUnderlyingCallsCount } }
|
|
set { subscribeToPaginationStateUpdatesListenerCallsCountLock.withLock { subscribeToPaginationStateUpdatesListenerUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var subscribeToPaginationStateUpdatesListenerCalled: Bool {
|
|
return subscribeToPaginationStateUpdatesListenerCallsCount > 0
|
|
}
|
|
private let subscribeToPaginationStateUpdatesListenerReceivedListenerLock = NSLock()
|
|
private var subscribeToPaginationStateUpdatesListenerUnderlyingReceivedListener: ThreadListPaginationStateListener?
|
|
open var subscribeToPaginationStateUpdatesListenerReceivedListener: ThreadListPaginationStateListener? {
|
|
get { subscribeToPaginationStateUpdatesListenerReceivedListenerLock.withLock { subscribeToPaginationStateUpdatesListenerUnderlyingReceivedListener } }
|
|
set { subscribeToPaginationStateUpdatesListenerReceivedListenerLock.withLock { subscribeToPaginationStateUpdatesListenerUnderlyingReceivedListener = newValue } }
|
|
}
|
|
private let subscribeToPaginationStateUpdatesListenerReceivedInvocationsLock = NSLock()
|
|
private var subscribeToPaginationStateUpdatesListenerUnderlyingReceivedInvocations: [ThreadListPaginationStateListener] = []
|
|
open var subscribeToPaginationStateUpdatesListenerReceivedInvocations: [ThreadListPaginationStateListener] {
|
|
get { subscribeToPaginationStateUpdatesListenerReceivedInvocationsLock.withLock { subscribeToPaginationStateUpdatesListenerUnderlyingReceivedInvocations } }
|
|
set { subscribeToPaginationStateUpdatesListenerReceivedInvocationsLock.withLock { subscribeToPaginationStateUpdatesListenerUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let subscribeToPaginationStateUpdatesListenerReturnValueLock = NSLock()
|
|
open var subscribeToPaginationStateUpdatesListenerUnderlyingReturnValue: TaskHandle!
|
|
open var subscribeToPaginationStateUpdatesListenerReturnValue: TaskHandle! {
|
|
get { subscribeToPaginationStateUpdatesListenerReturnValueLock.withLock { subscribeToPaginationStateUpdatesListenerUnderlyingReturnValue } }
|
|
set { subscribeToPaginationStateUpdatesListenerReturnValueLock.withLock { subscribeToPaginationStateUpdatesListenerUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var subscribeToPaginationStateUpdatesListenerClosure: ((ThreadListPaginationStateListener) -> TaskHandle)?
|
|
|
|
open override func subscribeToPaginationStateUpdates(listener: ThreadListPaginationStateListener) -> TaskHandle {
|
|
subscribeToPaginationStateUpdatesListenerCallsCountLock.withLock { subscribeToPaginationStateUpdatesListenerUnderlyingCallsCount += 1 }
|
|
subscribeToPaginationStateUpdatesListenerReceivedListener = listener
|
|
subscribeToPaginationStateUpdatesListenerReceivedInvocationsLock.withLock { subscribeToPaginationStateUpdatesListenerUnderlyingReceivedInvocations.append(listener) }
|
|
if let subscribeToPaginationStateUpdatesListenerClosure = subscribeToPaginationStateUpdatesListenerClosure {
|
|
return subscribeToPaginationStateUpdatesListenerClosure(listener)
|
|
} else {
|
|
return subscribeToPaginationStateUpdatesListenerReturnValue
|
|
}
|
|
}
|
|
}
|
|
open class ThreadSummarySDKMock: MatrixRustSDK.ThreadSummary, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
|
|
//MARK: - latestEvent
|
|
|
|
private let latestEventCallsCountLock = NSLock()
|
|
private var latestEventUnderlyingCallsCount = 0
|
|
open var latestEventCallsCount: Int {
|
|
get { latestEventCallsCountLock.withLock { latestEventUnderlyingCallsCount } }
|
|
set { latestEventCallsCountLock.withLock { latestEventUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var latestEventCalled: Bool {
|
|
return latestEventCallsCount > 0
|
|
}
|
|
|
|
private let latestEventReturnValueLock = NSLock()
|
|
open var latestEventUnderlyingReturnValue: EmbeddedEventDetails!
|
|
open var latestEventReturnValue: EmbeddedEventDetails! {
|
|
get { latestEventReturnValueLock.withLock { latestEventUnderlyingReturnValue } }
|
|
set { latestEventReturnValueLock.withLock { latestEventUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var latestEventClosure: (() -> EmbeddedEventDetails)?
|
|
|
|
open override func latestEvent() -> EmbeddedEventDetails {
|
|
latestEventCallsCountLock.withLock { latestEventUnderlyingCallsCount += 1 }
|
|
if let latestEventClosure = latestEventClosure {
|
|
return latestEventClosure()
|
|
} else {
|
|
return latestEventReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - numReplies
|
|
|
|
private let numRepliesCallsCountLock = NSLock()
|
|
private var numRepliesUnderlyingCallsCount = 0
|
|
open var numRepliesCallsCount: Int {
|
|
get { numRepliesCallsCountLock.withLock { numRepliesUnderlyingCallsCount } }
|
|
set { numRepliesCallsCountLock.withLock { numRepliesUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var numRepliesCalled: Bool {
|
|
return numRepliesCallsCount > 0
|
|
}
|
|
|
|
private let numRepliesReturnValueLock = NSLock()
|
|
open var numRepliesUnderlyingReturnValue: UInt64!
|
|
open var numRepliesReturnValue: UInt64! {
|
|
get { numRepliesReturnValueLock.withLock { numRepliesUnderlyingReturnValue } }
|
|
set { numRepliesReturnValueLock.withLock { numRepliesUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var numRepliesClosure: (() -> UInt64)?
|
|
|
|
open override func numReplies() -> UInt64 {
|
|
numRepliesCallsCountLock.withLock { numRepliesUnderlyingCallsCount += 1 }
|
|
if let numRepliesClosure = numRepliesClosure {
|
|
return numRepliesClosure()
|
|
} else {
|
|
return numRepliesReturnValue
|
|
}
|
|
}
|
|
}
|
|
open class TimelineSDKMock: MatrixRustSDK.Timeline, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
|
|
//MARK: - addListener
|
|
|
|
private let addListenerListenerCallsCountLock = NSLock()
|
|
private var addListenerListenerUnderlyingCallsCount = 0
|
|
open var addListenerListenerCallsCount: Int {
|
|
get { addListenerListenerCallsCountLock.withLock { addListenerListenerUnderlyingCallsCount } }
|
|
set { addListenerListenerCallsCountLock.withLock { addListenerListenerUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var addListenerListenerCalled: Bool {
|
|
return addListenerListenerCallsCount > 0
|
|
}
|
|
private let addListenerListenerReceivedListenerLock = NSLock()
|
|
private var addListenerListenerUnderlyingReceivedListener: TimelineListener?
|
|
open var addListenerListenerReceivedListener: TimelineListener? {
|
|
get { addListenerListenerReceivedListenerLock.withLock { addListenerListenerUnderlyingReceivedListener } }
|
|
set { addListenerListenerReceivedListenerLock.withLock { addListenerListenerUnderlyingReceivedListener = newValue } }
|
|
}
|
|
private let addListenerListenerReceivedInvocationsLock = NSLock()
|
|
private var addListenerListenerUnderlyingReceivedInvocations: [TimelineListener] = []
|
|
open var addListenerListenerReceivedInvocations: [TimelineListener] {
|
|
get { addListenerListenerReceivedInvocationsLock.withLock { addListenerListenerUnderlyingReceivedInvocations } }
|
|
set { addListenerListenerReceivedInvocationsLock.withLock { addListenerListenerUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let addListenerListenerReturnValueLock = NSLock()
|
|
open var addListenerListenerUnderlyingReturnValue: TaskHandle!
|
|
open var addListenerListenerReturnValue: TaskHandle! {
|
|
get { addListenerListenerReturnValueLock.withLock { addListenerListenerUnderlyingReturnValue } }
|
|
set { addListenerListenerReturnValueLock.withLock { addListenerListenerUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var addListenerListenerClosure: ((TimelineListener) async -> TaskHandle)?
|
|
|
|
open override func addListener(listener: TimelineListener) async -> TaskHandle {
|
|
addListenerListenerCallsCountLock.withLock { addListenerListenerUnderlyingCallsCount += 1 }
|
|
addListenerListenerReceivedListener = listener
|
|
addListenerListenerReceivedInvocationsLock.withLock { addListenerListenerUnderlyingReceivedInvocations.append(listener) }
|
|
if let addListenerListenerClosure = addListenerListenerClosure {
|
|
return await addListenerListenerClosure(listener)
|
|
} else {
|
|
return addListenerListenerReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - createMessageContent
|
|
|
|
private let createMessageContentMsgTypeCallsCountLock = NSLock()
|
|
private var createMessageContentMsgTypeUnderlyingCallsCount = 0
|
|
open var createMessageContentMsgTypeCallsCount: Int {
|
|
get { createMessageContentMsgTypeCallsCountLock.withLock { createMessageContentMsgTypeUnderlyingCallsCount } }
|
|
set { createMessageContentMsgTypeCallsCountLock.withLock { createMessageContentMsgTypeUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var createMessageContentMsgTypeCalled: Bool {
|
|
return createMessageContentMsgTypeCallsCount > 0
|
|
}
|
|
private let createMessageContentMsgTypeReceivedMsgTypeLock = NSLock()
|
|
private var createMessageContentMsgTypeUnderlyingReceivedMsgType: MessageType?
|
|
open var createMessageContentMsgTypeReceivedMsgType: MessageType? {
|
|
get { createMessageContentMsgTypeReceivedMsgTypeLock.withLock { createMessageContentMsgTypeUnderlyingReceivedMsgType } }
|
|
set { createMessageContentMsgTypeReceivedMsgTypeLock.withLock { createMessageContentMsgTypeUnderlyingReceivedMsgType = newValue } }
|
|
}
|
|
private let createMessageContentMsgTypeReceivedInvocationsLock = NSLock()
|
|
private var createMessageContentMsgTypeUnderlyingReceivedInvocations: [MessageType] = []
|
|
open var createMessageContentMsgTypeReceivedInvocations: [MessageType] {
|
|
get { createMessageContentMsgTypeReceivedInvocationsLock.withLock { createMessageContentMsgTypeUnderlyingReceivedInvocations } }
|
|
set { createMessageContentMsgTypeReceivedInvocationsLock.withLock { createMessageContentMsgTypeUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let createMessageContentMsgTypeReturnValueLock = NSLock()
|
|
open var createMessageContentMsgTypeUnderlyingReturnValue: RoomMessageEventContentWithoutRelation?
|
|
open var createMessageContentMsgTypeReturnValue: RoomMessageEventContentWithoutRelation? {
|
|
get { createMessageContentMsgTypeReturnValueLock.withLock { createMessageContentMsgTypeUnderlyingReturnValue } }
|
|
set { createMessageContentMsgTypeReturnValueLock.withLock { createMessageContentMsgTypeUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var createMessageContentMsgTypeClosure: ((MessageType) -> RoomMessageEventContentWithoutRelation?)?
|
|
|
|
open override func createMessageContent(msgType: MessageType) -> RoomMessageEventContentWithoutRelation? {
|
|
createMessageContentMsgTypeCallsCountLock.withLock { createMessageContentMsgTypeUnderlyingCallsCount += 1 }
|
|
createMessageContentMsgTypeReceivedMsgType = msgType
|
|
createMessageContentMsgTypeReceivedInvocationsLock.withLock { createMessageContentMsgTypeUnderlyingReceivedInvocations.append(msgType) }
|
|
if let createMessageContentMsgTypeClosure = createMessageContentMsgTypeClosure {
|
|
return createMessageContentMsgTypeClosure(msgType)
|
|
} else {
|
|
return createMessageContentMsgTypeReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - createPoll
|
|
|
|
open var createPollQuestionAnswersMaxSelectionsPollKindThrowableError: Error?
|
|
private let createPollQuestionAnswersMaxSelectionsPollKindCallsCountLock = NSLock()
|
|
private var createPollQuestionAnswersMaxSelectionsPollKindUnderlyingCallsCount = 0
|
|
open var createPollQuestionAnswersMaxSelectionsPollKindCallsCount: Int {
|
|
get { createPollQuestionAnswersMaxSelectionsPollKindCallsCountLock.withLock { createPollQuestionAnswersMaxSelectionsPollKindUnderlyingCallsCount } }
|
|
set { createPollQuestionAnswersMaxSelectionsPollKindCallsCountLock.withLock { createPollQuestionAnswersMaxSelectionsPollKindUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var createPollQuestionAnswersMaxSelectionsPollKindCalled: Bool {
|
|
return createPollQuestionAnswersMaxSelectionsPollKindCallsCount > 0
|
|
}
|
|
private let createPollQuestionAnswersMaxSelectionsPollKindReceivedArgumentsLock = NSLock()
|
|
private var createPollQuestionAnswersMaxSelectionsPollKindUnderlyingReceivedArguments: (question: String, answers: [String], maxSelections: UInt8, pollKind: PollKind)?
|
|
open var createPollQuestionAnswersMaxSelectionsPollKindReceivedArguments: (question: String, answers: [String], maxSelections: UInt8, pollKind: PollKind)? {
|
|
get { createPollQuestionAnswersMaxSelectionsPollKindReceivedArgumentsLock.withLock { createPollQuestionAnswersMaxSelectionsPollKindUnderlyingReceivedArguments } }
|
|
set { createPollQuestionAnswersMaxSelectionsPollKindReceivedArgumentsLock.withLock { createPollQuestionAnswersMaxSelectionsPollKindUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let createPollQuestionAnswersMaxSelectionsPollKindReceivedInvocationsLock = NSLock()
|
|
private var createPollQuestionAnswersMaxSelectionsPollKindUnderlyingReceivedInvocations: [(question: String, answers: [String], maxSelections: UInt8, pollKind: PollKind)] = []
|
|
open var createPollQuestionAnswersMaxSelectionsPollKindReceivedInvocations: [(question: String, answers: [String], maxSelections: UInt8, pollKind: PollKind)] {
|
|
get { createPollQuestionAnswersMaxSelectionsPollKindReceivedInvocationsLock.withLock { createPollQuestionAnswersMaxSelectionsPollKindUnderlyingReceivedInvocations } }
|
|
set { createPollQuestionAnswersMaxSelectionsPollKindReceivedInvocationsLock.withLock { createPollQuestionAnswersMaxSelectionsPollKindUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var createPollQuestionAnswersMaxSelectionsPollKindClosure: ((String, [String], UInt8, PollKind) async throws -> Void)?
|
|
|
|
open override func createPoll(question: String, answers: [String], maxSelections: UInt8, pollKind: PollKind) async throws {
|
|
if let error = createPollQuestionAnswersMaxSelectionsPollKindThrowableError {
|
|
throw error
|
|
}
|
|
createPollQuestionAnswersMaxSelectionsPollKindCallsCountLock.withLock { createPollQuestionAnswersMaxSelectionsPollKindUnderlyingCallsCount += 1 }
|
|
createPollQuestionAnswersMaxSelectionsPollKindReceivedArguments = (question: question, answers: answers, maxSelections: maxSelections, pollKind: pollKind)
|
|
createPollQuestionAnswersMaxSelectionsPollKindReceivedInvocationsLock.withLock { createPollQuestionAnswersMaxSelectionsPollKindUnderlyingReceivedInvocations.append((question: question, answers: answers, maxSelections: maxSelections, pollKind: pollKind)) }
|
|
try await createPollQuestionAnswersMaxSelectionsPollKindClosure?(question, answers, maxSelections, pollKind)
|
|
}
|
|
|
|
//MARK: - edit
|
|
|
|
open var editEventOrTransactionIdNewContentThrowableError: Error?
|
|
private let editEventOrTransactionIdNewContentCallsCountLock = NSLock()
|
|
private var editEventOrTransactionIdNewContentUnderlyingCallsCount = 0
|
|
open var editEventOrTransactionIdNewContentCallsCount: Int {
|
|
get { editEventOrTransactionIdNewContentCallsCountLock.withLock { editEventOrTransactionIdNewContentUnderlyingCallsCount } }
|
|
set { editEventOrTransactionIdNewContentCallsCountLock.withLock { editEventOrTransactionIdNewContentUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var editEventOrTransactionIdNewContentCalled: Bool {
|
|
return editEventOrTransactionIdNewContentCallsCount > 0
|
|
}
|
|
private let editEventOrTransactionIdNewContentReceivedArgumentsLock = NSLock()
|
|
private var editEventOrTransactionIdNewContentUnderlyingReceivedArguments: (eventOrTransactionId: EventOrTransactionId, newContent: EditedContent)?
|
|
open var editEventOrTransactionIdNewContentReceivedArguments: (eventOrTransactionId: EventOrTransactionId, newContent: EditedContent)? {
|
|
get { editEventOrTransactionIdNewContentReceivedArgumentsLock.withLock { editEventOrTransactionIdNewContentUnderlyingReceivedArguments } }
|
|
set { editEventOrTransactionIdNewContentReceivedArgumentsLock.withLock { editEventOrTransactionIdNewContentUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let editEventOrTransactionIdNewContentReceivedInvocationsLock = NSLock()
|
|
private var editEventOrTransactionIdNewContentUnderlyingReceivedInvocations: [(eventOrTransactionId: EventOrTransactionId, newContent: EditedContent)] = []
|
|
open var editEventOrTransactionIdNewContentReceivedInvocations: [(eventOrTransactionId: EventOrTransactionId, newContent: EditedContent)] {
|
|
get { editEventOrTransactionIdNewContentReceivedInvocationsLock.withLock { editEventOrTransactionIdNewContentUnderlyingReceivedInvocations } }
|
|
set { editEventOrTransactionIdNewContentReceivedInvocationsLock.withLock { editEventOrTransactionIdNewContentUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var editEventOrTransactionIdNewContentClosure: ((EventOrTransactionId, EditedContent) async throws -> Void)?
|
|
|
|
open override func edit(eventOrTransactionId: EventOrTransactionId, newContent: EditedContent) async throws {
|
|
if let error = editEventOrTransactionIdNewContentThrowableError {
|
|
throw error
|
|
}
|
|
editEventOrTransactionIdNewContentCallsCountLock.withLock { editEventOrTransactionIdNewContentUnderlyingCallsCount += 1 }
|
|
editEventOrTransactionIdNewContentReceivedArguments = (eventOrTransactionId: eventOrTransactionId, newContent: newContent)
|
|
editEventOrTransactionIdNewContentReceivedInvocationsLock.withLock { editEventOrTransactionIdNewContentUnderlyingReceivedInvocations.append((eventOrTransactionId: eventOrTransactionId, newContent: newContent)) }
|
|
try await editEventOrTransactionIdNewContentClosure?(eventOrTransactionId, newContent)
|
|
}
|
|
|
|
//MARK: - endPoll
|
|
|
|
open var endPollPollStartEventIdTextThrowableError: Error?
|
|
private let endPollPollStartEventIdTextCallsCountLock = NSLock()
|
|
private var endPollPollStartEventIdTextUnderlyingCallsCount = 0
|
|
open var endPollPollStartEventIdTextCallsCount: Int {
|
|
get { endPollPollStartEventIdTextCallsCountLock.withLock { endPollPollStartEventIdTextUnderlyingCallsCount } }
|
|
set { endPollPollStartEventIdTextCallsCountLock.withLock { endPollPollStartEventIdTextUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var endPollPollStartEventIdTextCalled: Bool {
|
|
return endPollPollStartEventIdTextCallsCount > 0
|
|
}
|
|
private let endPollPollStartEventIdTextReceivedArgumentsLock = NSLock()
|
|
private var endPollPollStartEventIdTextUnderlyingReceivedArguments: (pollStartEventId: String, text: String)?
|
|
open var endPollPollStartEventIdTextReceivedArguments: (pollStartEventId: String, text: String)? {
|
|
get { endPollPollStartEventIdTextReceivedArgumentsLock.withLock { endPollPollStartEventIdTextUnderlyingReceivedArguments } }
|
|
set { endPollPollStartEventIdTextReceivedArgumentsLock.withLock { endPollPollStartEventIdTextUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let endPollPollStartEventIdTextReceivedInvocationsLock = NSLock()
|
|
private var endPollPollStartEventIdTextUnderlyingReceivedInvocations: [(pollStartEventId: String, text: String)] = []
|
|
open var endPollPollStartEventIdTextReceivedInvocations: [(pollStartEventId: String, text: String)] {
|
|
get { endPollPollStartEventIdTextReceivedInvocationsLock.withLock { endPollPollStartEventIdTextUnderlyingReceivedInvocations } }
|
|
set { endPollPollStartEventIdTextReceivedInvocationsLock.withLock { endPollPollStartEventIdTextUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var endPollPollStartEventIdTextClosure: ((String, String) async throws -> Void)?
|
|
|
|
open override func endPoll(pollStartEventId: String, text: String) async throws {
|
|
if let error = endPollPollStartEventIdTextThrowableError {
|
|
throw error
|
|
}
|
|
endPollPollStartEventIdTextCallsCountLock.withLock { endPollPollStartEventIdTextUnderlyingCallsCount += 1 }
|
|
endPollPollStartEventIdTextReceivedArguments = (pollStartEventId: pollStartEventId, text: text)
|
|
endPollPollStartEventIdTextReceivedInvocationsLock.withLock { endPollPollStartEventIdTextUnderlyingReceivedInvocations.append((pollStartEventId: pollStartEventId, text: text)) }
|
|
try await endPollPollStartEventIdTextClosure?(pollStartEventId, text)
|
|
}
|
|
|
|
//MARK: - fetchDetailsForEvent
|
|
|
|
open var fetchDetailsForEventEventIdThrowableError: Error?
|
|
private let fetchDetailsForEventEventIdCallsCountLock = NSLock()
|
|
private var fetchDetailsForEventEventIdUnderlyingCallsCount = 0
|
|
open var fetchDetailsForEventEventIdCallsCount: Int {
|
|
get { fetchDetailsForEventEventIdCallsCountLock.withLock { fetchDetailsForEventEventIdUnderlyingCallsCount } }
|
|
set { fetchDetailsForEventEventIdCallsCountLock.withLock { fetchDetailsForEventEventIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var fetchDetailsForEventEventIdCalled: Bool {
|
|
return fetchDetailsForEventEventIdCallsCount > 0
|
|
}
|
|
private let fetchDetailsForEventEventIdReceivedEventIdLock = NSLock()
|
|
private var fetchDetailsForEventEventIdUnderlyingReceivedEventId: String?
|
|
open var fetchDetailsForEventEventIdReceivedEventId: String? {
|
|
get { fetchDetailsForEventEventIdReceivedEventIdLock.withLock { fetchDetailsForEventEventIdUnderlyingReceivedEventId } }
|
|
set { fetchDetailsForEventEventIdReceivedEventIdLock.withLock { fetchDetailsForEventEventIdUnderlyingReceivedEventId = newValue } }
|
|
}
|
|
private let fetchDetailsForEventEventIdReceivedInvocationsLock = NSLock()
|
|
private var fetchDetailsForEventEventIdUnderlyingReceivedInvocations: [String] = []
|
|
open var fetchDetailsForEventEventIdReceivedInvocations: [String] {
|
|
get { fetchDetailsForEventEventIdReceivedInvocationsLock.withLock { fetchDetailsForEventEventIdUnderlyingReceivedInvocations } }
|
|
set { fetchDetailsForEventEventIdReceivedInvocationsLock.withLock { fetchDetailsForEventEventIdUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var fetchDetailsForEventEventIdClosure: ((String) async throws -> Void)?
|
|
|
|
open override func fetchDetailsForEvent(eventId: String) async throws {
|
|
if let error = fetchDetailsForEventEventIdThrowableError {
|
|
throw error
|
|
}
|
|
fetchDetailsForEventEventIdCallsCountLock.withLock { fetchDetailsForEventEventIdUnderlyingCallsCount += 1 }
|
|
fetchDetailsForEventEventIdReceivedEventId = eventId
|
|
fetchDetailsForEventEventIdReceivedInvocationsLock.withLock { fetchDetailsForEventEventIdUnderlyingReceivedInvocations.append(eventId) }
|
|
try await fetchDetailsForEventEventIdClosure?(eventId)
|
|
}
|
|
|
|
//MARK: - fetchMembers
|
|
|
|
private let fetchMembersCallsCountLock = NSLock()
|
|
private var fetchMembersUnderlyingCallsCount = 0
|
|
open var fetchMembersCallsCount: Int {
|
|
get { fetchMembersCallsCountLock.withLock { fetchMembersUnderlyingCallsCount } }
|
|
set { fetchMembersCallsCountLock.withLock { fetchMembersUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var fetchMembersCalled: Bool {
|
|
return fetchMembersCallsCount > 0
|
|
}
|
|
open var fetchMembersClosure: (() async -> Void)?
|
|
|
|
open override func fetchMembers() async {
|
|
fetchMembersCallsCountLock.withLock { fetchMembersUnderlyingCallsCount += 1 }
|
|
await fetchMembersClosure?()
|
|
}
|
|
|
|
//MARK: - getEventTimelineItemByEventId
|
|
|
|
open var getEventTimelineItemByEventIdEventIdThrowableError: Error?
|
|
private let getEventTimelineItemByEventIdEventIdCallsCountLock = NSLock()
|
|
private var getEventTimelineItemByEventIdEventIdUnderlyingCallsCount = 0
|
|
open var getEventTimelineItemByEventIdEventIdCallsCount: Int {
|
|
get { getEventTimelineItemByEventIdEventIdCallsCountLock.withLock { getEventTimelineItemByEventIdEventIdUnderlyingCallsCount } }
|
|
set { getEventTimelineItemByEventIdEventIdCallsCountLock.withLock { getEventTimelineItemByEventIdEventIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var getEventTimelineItemByEventIdEventIdCalled: Bool {
|
|
return getEventTimelineItemByEventIdEventIdCallsCount > 0
|
|
}
|
|
private let getEventTimelineItemByEventIdEventIdReceivedEventIdLock = NSLock()
|
|
private var getEventTimelineItemByEventIdEventIdUnderlyingReceivedEventId: String?
|
|
open var getEventTimelineItemByEventIdEventIdReceivedEventId: String? {
|
|
get { getEventTimelineItemByEventIdEventIdReceivedEventIdLock.withLock { getEventTimelineItemByEventIdEventIdUnderlyingReceivedEventId } }
|
|
set { getEventTimelineItemByEventIdEventIdReceivedEventIdLock.withLock { getEventTimelineItemByEventIdEventIdUnderlyingReceivedEventId = newValue } }
|
|
}
|
|
private let getEventTimelineItemByEventIdEventIdReceivedInvocationsLock = NSLock()
|
|
private var getEventTimelineItemByEventIdEventIdUnderlyingReceivedInvocations: [String] = []
|
|
open var getEventTimelineItemByEventIdEventIdReceivedInvocations: [String] {
|
|
get { getEventTimelineItemByEventIdEventIdReceivedInvocationsLock.withLock { getEventTimelineItemByEventIdEventIdUnderlyingReceivedInvocations } }
|
|
set { getEventTimelineItemByEventIdEventIdReceivedInvocationsLock.withLock { getEventTimelineItemByEventIdEventIdUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let getEventTimelineItemByEventIdEventIdReturnValueLock = NSLock()
|
|
open var getEventTimelineItemByEventIdEventIdUnderlyingReturnValue: EventTimelineItem!
|
|
open var getEventTimelineItemByEventIdEventIdReturnValue: EventTimelineItem! {
|
|
get { getEventTimelineItemByEventIdEventIdReturnValueLock.withLock { getEventTimelineItemByEventIdEventIdUnderlyingReturnValue } }
|
|
set { getEventTimelineItemByEventIdEventIdReturnValueLock.withLock { getEventTimelineItemByEventIdEventIdUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var getEventTimelineItemByEventIdEventIdClosure: ((String) async throws -> EventTimelineItem)?
|
|
|
|
open override func getEventTimelineItemByEventId(eventId: String) async throws -> EventTimelineItem {
|
|
if let error = getEventTimelineItemByEventIdEventIdThrowableError {
|
|
throw error
|
|
}
|
|
getEventTimelineItemByEventIdEventIdCallsCountLock.withLock { getEventTimelineItemByEventIdEventIdUnderlyingCallsCount += 1 }
|
|
getEventTimelineItemByEventIdEventIdReceivedEventId = eventId
|
|
getEventTimelineItemByEventIdEventIdReceivedInvocationsLock.withLock { getEventTimelineItemByEventIdEventIdUnderlyingReceivedInvocations.append(eventId) }
|
|
if let getEventTimelineItemByEventIdEventIdClosure = getEventTimelineItemByEventIdEventIdClosure {
|
|
return try await getEventTimelineItemByEventIdEventIdClosure(eventId)
|
|
} else {
|
|
return getEventTimelineItemByEventIdEventIdReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - latestEventId
|
|
|
|
private let latestEventIdCallsCountLock = NSLock()
|
|
private var latestEventIdUnderlyingCallsCount = 0
|
|
open var latestEventIdCallsCount: Int {
|
|
get { latestEventIdCallsCountLock.withLock { latestEventIdUnderlyingCallsCount } }
|
|
set { latestEventIdCallsCountLock.withLock { latestEventIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var latestEventIdCalled: Bool {
|
|
return latestEventIdCallsCount > 0
|
|
}
|
|
|
|
private let latestEventIdReturnValueLock = NSLock()
|
|
open var latestEventIdUnderlyingReturnValue: String?
|
|
open var latestEventIdReturnValue: String? {
|
|
get { latestEventIdReturnValueLock.withLock { latestEventIdUnderlyingReturnValue } }
|
|
set { latestEventIdReturnValueLock.withLock { latestEventIdUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var latestEventIdClosure: (() async -> String?)?
|
|
|
|
open override func latestEventId() async -> String? {
|
|
latestEventIdCallsCountLock.withLock { latestEventIdUnderlyingCallsCount += 1 }
|
|
if let latestEventIdClosure = latestEventIdClosure {
|
|
return await latestEventIdClosure()
|
|
} else {
|
|
return latestEventIdReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - loadReplyDetails
|
|
|
|
open var loadReplyDetailsEventIdStrThrowableError: Error?
|
|
private let loadReplyDetailsEventIdStrCallsCountLock = NSLock()
|
|
private var loadReplyDetailsEventIdStrUnderlyingCallsCount = 0
|
|
open var loadReplyDetailsEventIdStrCallsCount: Int {
|
|
get { loadReplyDetailsEventIdStrCallsCountLock.withLock { loadReplyDetailsEventIdStrUnderlyingCallsCount } }
|
|
set { loadReplyDetailsEventIdStrCallsCountLock.withLock { loadReplyDetailsEventIdStrUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var loadReplyDetailsEventIdStrCalled: Bool {
|
|
return loadReplyDetailsEventIdStrCallsCount > 0
|
|
}
|
|
private let loadReplyDetailsEventIdStrReceivedEventIdStrLock = NSLock()
|
|
private var loadReplyDetailsEventIdStrUnderlyingReceivedEventIdStr: String?
|
|
open var loadReplyDetailsEventIdStrReceivedEventIdStr: String? {
|
|
get { loadReplyDetailsEventIdStrReceivedEventIdStrLock.withLock { loadReplyDetailsEventIdStrUnderlyingReceivedEventIdStr } }
|
|
set { loadReplyDetailsEventIdStrReceivedEventIdStrLock.withLock { loadReplyDetailsEventIdStrUnderlyingReceivedEventIdStr = newValue } }
|
|
}
|
|
private let loadReplyDetailsEventIdStrReceivedInvocationsLock = NSLock()
|
|
private var loadReplyDetailsEventIdStrUnderlyingReceivedInvocations: [String] = []
|
|
open var loadReplyDetailsEventIdStrReceivedInvocations: [String] {
|
|
get { loadReplyDetailsEventIdStrReceivedInvocationsLock.withLock { loadReplyDetailsEventIdStrUnderlyingReceivedInvocations } }
|
|
set { loadReplyDetailsEventIdStrReceivedInvocationsLock.withLock { loadReplyDetailsEventIdStrUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let loadReplyDetailsEventIdStrReturnValueLock = NSLock()
|
|
open var loadReplyDetailsEventIdStrUnderlyingReturnValue: InReplyToDetails!
|
|
open var loadReplyDetailsEventIdStrReturnValue: InReplyToDetails! {
|
|
get { loadReplyDetailsEventIdStrReturnValueLock.withLock { loadReplyDetailsEventIdStrUnderlyingReturnValue } }
|
|
set { loadReplyDetailsEventIdStrReturnValueLock.withLock { loadReplyDetailsEventIdStrUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var loadReplyDetailsEventIdStrClosure: ((String) async throws -> InReplyToDetails)?
|
|
|
|
open override func loadReplyDetails(eventIdStr: String) async throws -> InReplyToDetails {
|
|
if let error = loadReplyDetailsEventIdStrThrowableError {
|
|
throw error
|
|
}
|
|
loadReplyDetailsEventIdStrCallsCountLock.withLock { loadReplyDetailsEventIdStrUnderlyingCallsCount += 1 }
|
|
loadReplyDetailsEventIdStrReceivedEventIdStr = eventIdStr
|
|
loadReplyDetailsEventIdStrReceivedInvocationsLock.withLock { loadReplyDetailsEventIdStrUnderlyingReceivedInvocations.append(eventIdStr) }
|
|
if let loadReplyDetailsEventIdStrClosure = loadReplyDetailsEventIdStrClosure {
|
|
return try await loadReplyDetailsEventIdStrClosure(eventIdStr)
|
|
} else {
|
|
return loadReplyDetailsEventIdStrReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - markAsRead
|
|
|
|
open var markAsReadReceiptTypeThrowableError: Error?
|
|
private let markAsReadReceiptTypeCallsCountLock = NSLock()
|
|
private var markAsReadReceiptTypeUnderlyingCallsCount = 0
|
|
open var markAsReadReceiptTypeCallsCount: Int {
|
|
get { markAsReadReceiptTypeCallsCountLock.withLock { markAsReadReceiptTypeUnderlyingCallsCount } }
|
|
set { markAsReadReceiptTypeCallsCountLock.withLock { markAsReadReceiptTypeUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var markAsReadReceiptTypeCalled: Bool {
|
|
return markAsReadReceiptTypeCallsCount > 0
|
|
}
|
|
private let markAsReadReceiptTypeReceivedReceiptTypeLock = NSLock()
|
|
private var markAsReadReceiptTypeUnderlyingReceivedReceiptType: ReceiptType?
|
|
open var markAsReadReceiptTypeReceivedReceiptType: ReceiptType? {
|
|
get { markAsReadReceiptTypeReceivedReceiptTypeLock.withLock { markAsReadReceiptTypeUnderlyingReceivedReceiptType } }
|
|
set { markAsReadReceiptTypeReceivedReceiptTypeLock.withLock { markAsReadReceiptTypeUnderlyingReceivedReceiptType = newValue } }
|
|
}
|
|
private let markAsReadReceiptTypeReceivedInvocationsLock = NSLock()
|
|
private var markAsReadReceiptTypeUnderlyingReceivedInvocations: [ReceiptType] = []
|
|
open var markAsReadReceiptTypeReceivedInvocations: [ReceiptType] {
|
|
get { markAsReadReceiptTypeReceivedInvocationsLock.withLock { markAsReadReceiptTypeUnderlyingReceivedInvocations } }
|
|
set { markAsReadReceiptTypeReceivedInvocationsLock.withLock { markAsReadReceiptTypeUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var markAsReadReceiptTypeClosure: ((ReceiptType) async throws -> Void)?
|
|
|
|
open override func markAsRead(receiptType: ReceiptType) async throws {
|
|
if let error = markAsReadReceiptTypeThrowableError {
|
|
throw error
|
|
}
|
|
markAsReadReceiptTypeCallsCountLock.withLock { markAsReadReceiptTypeUnderlyingCallsCount += 1 }
|
|
markAsReadReceiptTypeReceivedReceiptType = receiptType
|
|
markAsReadReceiptTypeReceivedInvocationsLock.withLock { markAsReadReceiptTypeUnderlyingReceivedInvocations.append(receiptType) }
|
|
try await markAsReadReceiptTypeClosure?(receiptType)
|
|
}
|
|
|
|
//MARK: - paginateBackwards
|
|
|
|
open var paginateBackwardsNumEventsThrowableError: Error?
|
|
private let paginateBackwardsNumEventsCallsCountLock = NSLock()
|
|
private var paginateBackwardsNumEventsUnderlyingCallsCount = 0
|
|
open var paginateBackwardsNumEventsCallsCount: Int {
|
|
get { paginateBackwardsNumEventsCallsCountLock.withLock { paginateBackwardsNumEventsUnderlyingCallsCount } }
|
|
set { paginateBackwardsNumEventsCallsCountLock.withLock { paginateBackwardsNumEventsUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var paginateBackwardsNumEventsCalled: Bool {
|
|
return paginateBackwardsNumEventsCallsCount > 0
|
|
}
|
|
private let paginateBackwardsNumEventsReceivedNumEventsLock = NSLock()
|
|
private var paginateBackwardsNumEventsUnderlyingReceivedNumEvents: UInt16?
|
|
open var paginateBackwardsNumEventsReceivedNumEvents: UInt16? {
|
|
get { paginateBackwardsNumEventsReceivedNumEventsLock.withLock { paginateBackwardsNumEventsUnderlyingReceivedNumEvents } }
|
|
set { paginateBackwardsNumEventsReceivedNumEventsLock.withLock { paginateBackwardsNumEventsUnderlyingReceivedNumEvents = newValue } }
|
|
}
|
|
private let paginateBackwardsNumEventsReceivedInvocationsLock = NSLock()
|
|
private var paginateBackwardsNumEventsUnderlyingReceivedInvocations: [UInt16] = []
|
|
open var paginateBackwardsNumEventsReceivedInvocations: [UInt16] {
|
|
get { paginateBackwardsNumEventsReceivedInvocationsLock.withLock { paginateBackwardsNumEventsUnderlyingReceivedInvocations } }
|
|
set { paginateBackwardsNumEventsReceivedInvocationsLock.withLock { paginateBackwardsNumEventsUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let paginateBackwardsNumEventsReturnValueLock = NSLock()
|
|
open var paginateBackwardsNumEventsUnderlyingReturnValue: Bool!
|
|
open var paginateBackwardsNumEventsReturnValue: Bool! {
|
|
get { paginateBackwardsNumEventsReturnValueLock.withLock { paginateBackwardsNumEventsUnderlyingReturnValue } }
|
|
set { paginateBackwardsNumEventsReturnValueLock.withLock { paginateBackwardsNumEventsUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var paginateBackwardsNumEventsClosure: ((UInt16) async throws -> Bool)?
|
|
|
|
open override func paginateBackwards(numEvents: UInt16) async throws -> Bool {
|
|
if let error = paginateBackwardsNumEventsThrowableError {
|
|
throw error
|
|
}
|
|
paginateBackwardsNumEventsCallsCountLock.withLock { paginateBackwardsNumEventsUnderlyingCallsCount += 1 }
|
|
paginateBackwardsNumEventsReceivedNumEvents = numEvents
|
|
paginateBackwardsNumEventsReceivedInvocationsLock.withLock { paginateBackwardsNumEventsUnderlyingReceivedInvocations.append(numEvents) }
|
|
if let paginateBackwardsNumEventsClosure = paginateBackwardsNumEventsClosure {
|
|
return try await paginateBackwardsNumEventsClosure(numEvents)
|
|
} else {
|
|
return paginateBackwardsNumEventsReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - paginateForwards
|
|
|
|
open var paginateForwardsNumEventsThrowableError: Error?
|
|
private let paginateForwardsNumEventsCallsCountLock = NSLock()
|
|
private var paginateForwardsNumEventsUnderlyingCallsCount = 0
|
|
open var paginateForwardsNumEventsCallsCount: Int {
|
|
get { paginateForwardsNumEventsCallsCountLock.withLock { paginateForwardsNumEventsUnderlyingCallsCount } }
|
|
set { paginateForwardsNumEventsCallsCountLock.withLock { paginateForwardsNumEventsUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var paginateForwardsNumEventsCalled: Bool {
|
|
return paginateForwardsNumEventsCallsCount > 0
|
|
}
|
|
private let paginateForwardsNumEventsReceivedNumEventsLock = NSLock()
|
|
private var paginateForwardsNumEventsUnderlyingReceivedNumEvents: UInt16?
|
|
open var paginateForwardsNumEventsReceivedNumEvents: UInt16? {
|
|
get { paginateForwardsNumEventsReceivedNumEventsLock.withLock { paginateForwardsNumEventsUnderlyingReceivedNumEvents } }
|
|
set { paginateForwardsNumEventsReceivedNumEventsLock.withLock { paginateForwardsNumEventsUnderlyingReceivedNumEvents = newValue } }
|
|
}
|
|
private let paginateForwardsNumEventsReceivedInvocationsLock = NSLock()
|
|
private var paginateForwardsNumEventsUnderlyingReceivedInvocations: [UInt16] = []
|
|
open var paginateForwardsNumEventsReceivedInvocations: [UInt16] {
|
|
get { paginateForwardsNumEventsReceivedInvocationsLock.withLock { paginateForwardsNumEventsUnderlyingReceivedInvocations } }
|
|
set { paginateForwardsNumEventsReceivedInvocationsLock.withLock { paginateForwardsNumEventsUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let paginateForwardsNumEventsReturnValueLock = NSLock()
|
|
open var paginateForwardsNumEventsUnderlyingReturnValue: Bool!
|
|
open var paginateForwardsNumEventsReturnValue: Bool! {
|
|
get { paginateForwardsNumEventsReturnValueLock.withLock { paginateForwardsNumEventsUnderlyingReturnValue } }
|
|
set { paginateForwardsNumEventsReturnValueLock.withLock { paginateForwardsNumEventsUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var paginateForwardsNumEventsClosure: ((UInt16) async throws -> Bool)?
|
|
|
|
open override func paginateForwards(numEvents: UInt16) async throws -> Bool {
|
|
if let error = paginateForwardsNumEventsThrowableError {
|
|
throw error
|
|
}
|
|
paginateForwardsNumEventsCallsCountLock.withLock { paginateForwardsNumEventsUnderlyingCallsCount += 1 }
|
|
paginateForwardsNumEventsReceivedNumEvents = numEvents
|
|
paginateForwardsNumEventsReceivedInvocationsLock.withLock { paginateForwardsNumEventsUnderlyingReceivedInvocations.append(numEvents) }
|
|
if let paginateForwardsNumEventsClosure = paginateForwardsNumEventsClosure {
|
|
return try await paginateForwardsNumEventsClosure(numEvents)
|
|
} else {
|
|
return paginateForwardsNumEventsReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - pinEvent
|
|
|
|
open var pinEventEventIdThrowableError: Error?
|
|
private let pinEventEventIdCallsCountLock = NSLock()
|
|
private var pinEventEventIdUnderlyingCallsCount = 0
|
|
open var pinEventEventIdCallsCount: Int {
|
|
get { pinEventEventIdCallsCountLock.withLock { pinEventEventIdUnderlyingCallsCount } }
|
|
set { pinEventEventIdCallsCountLock.withLock { pinEventEventIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var pinEventEventIdCalled: Bool {
|
|
return pinEventEventIdCallsCount > 0
|
|
}
|
|
private let pinEventEventIdReceivedEventIdLock = NSLock()
|
|
private var pinEventEventIdUnderlyingReceivedEventId: String?
|
|
open var pinEventEventIdReceivedEventId: String? {
|
|
get { pinEventEventIdReceivedEventIdLock.withLock { pinEventEventIdUnderlyingReceivedEventId } }
|
|
set { pinEventEventIdReceivedEventIdLock.withLock { pinEventEventIdUnderlyingReceivedEventId = newValue } }
|
|
}
|
|
private let pinEventEventIdReceivedInvocationsLock = NSLock()
|
|
private var pinEventEventIdUnderlyingReceivedInvocations: [String] = []
|
|
open var pinEventEventIdReceivedInvocations: [String] {
|
|
get { pinEventEventIdReceivedInvocationsLock.withLock { pinEventEventIdUnderlyingReceivedInvocations } }
|
|
set { pinEventEventIdReceivedInvocationsLock.withLock { pinEventEventIdUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let pinEventEventIdReturnValueLock = NSLock()
|
|
open var pinEventEventIdUnderlyingReturnValue: Bool!
|
|
open var pinEventEventIdReturnValue: Bool! {
|
|
get { pinEventEventIdReturnValueLock.withLock { pinEventEventIdUnderlyingReturnValue } }
|
|
set { pinEventEventIdReturnValueLock.withLock { pinEventEventIdUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var pinEventEventIdClosure: ((String) async throws -> Bool)?
|
|
|
|
open override func pinEvent(eventId: String) async throws -> Bool {
|
|
if let error = pinEventEventIdThrowableError {
|
|
throw error
|
|
}
|
|
pinEventEventIdCallsCountLock.withLock { pinEventEventIdUnderlyingCallsCount += 1 }
|
|
pinEventEventIdReceivedEventId = eventId
|
|
pinEventEventIdReceivedInvocationsLock.withLock { pinEventEventIdUnderlyingReceivedInvocations.append(eventId) }
|
|
if let pinEventEventIdClosure = pinEventEventIdClosure {
|
|
return try await pinEventEventIdClosure(eventId)
|
|
} else {
|
|
return pinEventEventIdReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - redactEvent
|
|
|
|
open var redactEventEventOrTransactionIdReasonThrowableError: Error?
|
|
private let redactEventEventOrTransactionIdReasonCallsCountLock = NSLock()
|
|
private var redactEventEventOrTransactionIdReasonUnderlyingCallsCount = 0
|
|
open var redactEventEventOrTransactionIdReasonCallsCount: Int {
|
|
get { redactEventEventOrTransactionIdReasonCallsCountLock.withLock { redactEventEventOrTransactionIdReasonUnderlyingCallsCount } }
|
|
set { redactEventEventOrTransactionIdReasonCallsCountLock.withLock { redactEventEventOrTransactionIdReasonUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var redactEventEventOrTransactionIdReasonCalled: Bool {
|
|
return redactEventEventOrTransactionIdReasonCallsCount > 0
|
|
}
|
|
private let redactEventEventOrTransactionIdReasonReceivedArgumentsLock = NSLock()
|
|
private var redactEventEventOrTransactionIdReasonUnderlyingReceivedArguments: (eventOrTransactionId: EventOrTransactionId, reason: String?)?
|
|
open var redactEventEventOrTransactionIdReasonReceivedArguments: (eventOrTransactionId: EventOrTransactionId, reason: String?)? {
|
|
get { redactEventEventOrTransactionIdReasonReceivedArgumentsLock.withLock { redactEventEventOrTransactionIdReasonUnderlyingReceivedArguments } }
|
|
set { redactEventEventOrTransactionIdReasonReceivedArgumentsLock.withLock { redactEventEventOrTransactionIdReasonUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let redactEventEventOrTransactionIdReasonReceivedInvocationsLock = NSLock()
|
|
private var redactEventEventOrTransactionIdReasonUnderlyingReceivedInvocations: [(eventOrTransactionId: EventOrTransactionId, reason: String?)] = []
|
|
open var redactEventEventOrTransactionIdReasonReceivedInvocations: [(eventOrTransactionId: EventOrTransactionId, reason: String?)] {
|
|
get { redactEventEventOrTransactionIdReasonReceivedInvocationsLock.withLock { redactEventEventOrTransactionIdReasonUnderlyingReceivedInvocations } }
|
|
set { redactEventEventOrTransactionIdReasonReceivedInvocationsLock.withLock { redactEventEventOrTransactionIdReasonUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var redactEventEventOrTransactionIdReasonClosure: ((EventOrTransactionId, String?) async throws -> Void)?
|
|
|
|
open override func redactEvent(eventOrTransactionId: EventOrTransactionId, reason: String?) async throws {
|
|
if let error = redactEventEventOrTransactionIdReasonThrowableError {
|
|
throw error
|
|
}
|
|
redactEventEventOrTransactionIdReasonCallsCountLock.withLock { redactEventEventOrTransactionIdReasonUnderlyingCallsCount += 1 }
|
|
redactEventEventOrTransactionIdReasonReceivedArguments = (eventOrTransactionId: eventOrTransactionId, reason: reason)
|
|
redactEventEventOrTransactionIdReasonReceivedInvocationsLock.withLock { redactEventEventOrTransactionIdReasonUnderlyingReceivedInvocations.append((eventOrTransactionId: eventOrTransactionId, reason: reason)) }
|
|
try await redactEventEventOrTransactionIdReasonClosure?(eventOrTransactionId, reason)
|
|
}
|
|
|
|
//MARK: - retryDecryption
|
|
|
|
private let retryDecryptionSessionIdsCallsCountLock = NSLock()
|
|
private var retryDecryptionSessionIdsUnderlyingCallsCount = 0
|
|
open var retryDecryptionSessionIdsCallsCount: Int {
|
|
get { retryDecryptionSessionIdsCallsCountLock.withLock { retryDecryptionSessionIdsUnderlyingCallsCount } }
|
|
set { retryDecryptionSessionIdsCallsCountLock.withLock { retryDecryptionSessionIdsUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var retryDecryptionSessionIdsCalled: Bool {
|
|
return retryDecryptionSessionIdsCallsCount > 0
|
|
}
|
|
private let retryDecryptionSessionIdsReceivedSessionIdsLock = NSLock()
|
|
private var retryDecryptionSessionIdsUnderlyingReceivedSessionIds: [String]?
|
|
open var retryDecryptionSessionIdsReceivedSessionIds: [String]? {
|
|
get { retryDecryptionSessionIdsReceivedSessionIdsLock.withLock { retryDecryptionSessionIdsUnderlyingReceivedSessionIds } }
|
|
set { retryDecryptionSessionIdsReceivedSessionIdsLock.withLock { retryDecryptionSessionIdsUnderlyingReceivedSessionIds = newValue } }
|
|
}
|
|
private let retryDecryptionSessionIdsReceivedInvocationsLock = NSLock()
|
|
private var retryDecryptionSessionIdsUnderlyingReceivedInvocations: [[String]] = []
|
|
open var retryDecryptionSessionIdsReceivedInvocations: [[String]] {
|
|
get { retryDecryptionSessionIdsReceivedInvocationsLock.withLock { retryDecryptionSessionIdsUnderlyingReceivedInvocations } }
|
|
set { retryDecryptionSessionIdsReceivedInvocationsLock.withLock { retryDecryptionSessionIdsUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var retryDecryptionSessionIdsClosure: (([String]) -> Void)?
|
|
|
|
open override func retryDecryption(sessionIds: [String]) {
|
|
retryDecryptionSessionIdsCallsCountLock.withLock { retryDecryptionSessionIdsUnderlyingCallsCount += 1 }
|
|
retryDecryptionSessionIdsReceivedSessionIds = sessionIds
|
|
retryDecryptionSessionIdsReceivedInvocationsLock.withLock { retryDecryptionSessionIdsUnderlyingReceivedInvocations.append(sessionIds) }
|
|
retryDecryptionSessionIdsClosure?(sessionIds)
|
|
}
|
|
|
|
//MARK: - send
|
|
|
|
open var sendMsgThrowableError: Error?
|
|
private let sendMsgCallsCountLock = NSLock()
|
|
private var sendMsgUnderlyingCallsCount = 0
|
|
open var sendMsgCallsCount: Int {
|
|
get { sendMsgCallsCountLock.withLock { sendMsgUnderlyingCallsCount } }
|
|
set { sendMsgCallsCountLock.withLock { sendMsgUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var sendMsgCalled: Bool {
|
|
return sendMsgCallsCount > 0
|
|
}
|
|
private let sendMsgReceivedMsgLock = NSLock()
|
|
private var sendMsgUnderlyingReceivedMsg: RoomMessageEventContentWithoutRelation?
|
|
open var sendMsgReceivedMsg: RoomMessageEventContentWithoutRelation? {
|
|
get { sendMsgReceivedMsgLock.withLock { sendMsgUnderlyingReceivedMsg } }
|
|
set { sendMsgReceivedMsgLock.withLock { sendMsgUnderlyingReceivedMsg = newValue } }
|
|
}
|
|
private let sendMsgReceivedInvocationsLock = NSLock()
|
|
private var sendMsgUnderlyingReceivedInvocations: [RoomMessageEventContentWithoutRelation] = []
|
|
open var sendMsgReceivedInvocations: [RoomMessageEventContentWithoutRelation] {
|
|
get { sendMsgReceivedInvocationsLock.withLock { sendMsgUnderlyingReceivedInvocations } }
|
|
set { sendMsgReceivedInvocationsLock.withLock { sendMsgUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let sendMsgReturnValueLock = NSLock()
|
|
open var sendMsgUnderlyingReturnValue: SendHandle!
|
|
open var sendMsgReturnValue: SendHandle! {
|
|
get { sendMsgReturnValueLock.withLock { sendMsgUnderlyingReturnValue } }
|
|
set { sendMsgReturnValueLock.withLock { sendMsgUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var sendMsgClosure: ((RoomMessageEventContentWithoutRelation) async throws -> SendHandle)?
|
|
|
|
open override func send(msg: RoomMessageEventContentWithoutRelation) async throws -> SendHandle {
|
|
if let error = sendMsgThrowableError {
|
|
throw error
|
|
}
|
|
sendMsgCallsCountLock.withLock { sendMsgUnderlyingCallsCount += 1 }
|
|
sendMsgReceivedMsg = msg
|
|
sendMsgReceivedInvocationsLock.withLock { sendMsgUnderlyingReceivedInvocations.append(msg) }
|
|
if let sendMsgClosure = sendMsgClosure {
|
|
return try await sendMsgClosure(msg)
|
|
} else {
|
|
return sendMsgReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - sendAudio
|
|
|
|
open var sendAudioParamsAudioInfoThrowableError: Error?
|
|
private let sendAudioParamsAudioInfoCallsCountLock = NSLock()
|
|
private var sendAudioParamsAudioInfoUnderlyingCallsCount = 0
|
|
open var sendAudioParamsAudioInfoCallsCount: Int {
|
|
get { sendAudioParamsAudioInfoCallsCountLock.withLock { sendAudioParamsAudioInfoUnderlyingCallsCount } }
|
|
set { sendAudioParamsAudioInfoCallsCountLock.withLock { sendAudioParamsAudioInfoUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var sendAudioParamsAudioInfoCalled: Bool {
|
|
return sendAudioParamsAudioInfoCallsCount > 0
|
|
}
|
|
private let sendAudioParamsAudioInfoReceivedArgumentsLock = NSLock()
|
|
private var sendAudioParamsAudioInfoUnderlyingReceivedArguments: (params: UploadParameters, audioInfo: AudioInfo)?
|
|
open var sendAudioParamsAudioInfoReceivedArguments: (params: UploadParameters, audioInfo: AudioInfo)? {
|
|
get { sendAudioParamsAudioInfoReceivedArgumentsLock.withLock { sendAudioParamsAudioInfoUnderlyingReceivedArguments } }
|
|
set { sendAudioParamsAudioInfoReceivedArgumentsLock.withLock { sendAudioParamsAudioInfoUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let sendAudioParamsAudioInfoReceivedInvocationsLock = NSLock()
|
|
private var sendAudioParamsAudioInfoUnderlyingReceivedInvocations: [(params: UploadParameters, audioInfo: AudioInfo)] = []
|
|
open var sendAudioParamsAudioInfoReceivedInvocations: [(params: UploadParameters, audioInfo: AudioInfo)] {
|
|
get { sendAudioParamsAudioInfoReceivedInvocationsLock.withLock { sendAudioParamsAudioInfoUnderlyingReceivedInvocations } }
|
|
set { sendAudioParamsAudioInfoReceivedInvocationsLock.withLock { sendAudioParamsAudioInfoUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let sendAudioParamsAudioInfoReturnValueLock = NSLock()
|
|
open var sendAudioParamsAudioInfoUnderlyingReturnValue: SendAttachmentJoinHandle!
|
|
open var sendAudioParamsAudioInfoReturnValue: SendAttachmentJoinHandle! {
|
|
get { sendAudioParamsAudioInfoReturnValueLock.withLock { sendAudioParamsAudioInfoUnderlyingReturnValue } }
|
|
set { sendAudioParamsAudioInfoReturnValueLock.withLock { sendAudioParamsAudioInfoUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var sendAudioParamsAudioInfoClosure: ((UploadParameters, AudioInfo) throws -> SendAttachmentJoinHandle)?
|
|
|
|
open override func sendAudio(params: UploadParameters, audioInfo: AudioInfo) throws -> SendAttachmentJoinHandle {
|
|
if let error = sendAudioParamsAudioInfoThrowableError {
|
|
throw error
|
|
}
|
|
sendAudioParamsAudioInfoCallsCountLock.withLock { sendAudioParamsAudioInfoUnderlyingCallsCount += 1 }
|
|
sendAudioParamsAudioInfoReceivedArguments = (params: params, audioInfo: audioInfo)
|
|
sendAudioParamsAudioInfoReceivedInvocationsLock.withLock { sendAudioParamsAudioInfoUnderlyingReceivedInvocations.append((params: params, audioInfo: audioInfo)) }
|
|
if let sendAudioParamsAudioInfoClosure = sendAudioParamsAudioInfoClosure {
|
|
return try sendAudioParamsAudioInfoClosure(params, audioInfo)
|
|
} else {
|
|
return sendAudioParamsAudioInfoReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - sendFile
|
|
|
|
open var sendFileParamsFileInfoThrowableError: Error?
|
|
private let sendFileParamsFileInfoCallsCountLock = NSLock()
|
|
private var sendFileParamsFileInfoUnderlyingCallsCount = 0
|
|
open var sendFileParamsFileInfoCallsCount: Int {
|
|
get { sendFileParamsFileInfoCallsCountLock.withLock { sendFileParamsFileInfoUnderlyingCallsCount } }
|
|
set { sendFileParamsFileInfoCallsCountLock.withLock { sendFileParamsFileInfoUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var sendFileParamsFileInfoCalled: Bool {
|
|
return sendFileParamsFileInfoCallsCount > 0
|
|
}
|
|
private let sendFileParamsFileInfoReceivedArgumentsLock = NSLock()
|
|
private var sendFileParamsFileInfoUnderlyingReceivedArguments: (params: UploadParameters, fileInfo: FileInfo)?
|
|
open var sendFileParamsFileInfoReceivedArguments: (params: UploadParameters, fileInfo: FileInfo)? {
|
|
get { sendFileParamsFileInfoReceivedArgumentsLock.withLock { sendFileParamsFileInfoUnderlyingReceivedArguments } }
|
|
set { sendFileParamsFileInfoReceivedArgumentsLock.withLock { sendFileParamsFileInfoUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let sendFileParamsFileInfoReceivedInvocationsLock = NSLock()
|
|
private var sendFileParamsFileInfoUnderlyingReceivedInvocations: [(params: UploadParameters, fileInfo: FileInfo)] = []
|
|
open var sendFileParamsFileInfoReceivedInvocations: [(params: UploadParameters, fileInfo: FileInfo)] {
|
|
get { sendFileParamsFileInfoReceivedInvocationsLock.withLock { sendFileParamsFileInfoUnderlyingReceivedInvocations } }
|
|
set { sendFileParamsFileInfoReceivedInvocationsLock.withLock { sendFileParamsFileInfoUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let sendFileParamsFileInfoReturnValueLock = NSLock()
|
|
open var sendFileParamsFileInfoUnderlyingReturnValue: SendAttachmentJoinHandle!
|
|
open var sendFileParamsFileInfoReturnValue: SendAttachmentJoinHandle! {
|
|
get { sendFileParamsFileInfoReturnValueLock.withLock { sendFileParamsFileInfoUnderlyingReturnValue } }
|
|
set { sendFileParamsFileInfoReturnValueLock.withLock { sendFileParamsFileInfoUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var sendFileParamsFileInfoClosure: ((UploadParameters, FileInfo) throws -> SendAttachmentJoinHandle)?
|
|
|
|
open override func sendFile(params: UploadParameters, fileInfo: FileInfo) throws -> SendAttachmentJoinHandle {
|
|
if let error = sendFileParamsFileInfoThrowableError {
|
|
throw error
|
|
}
|
|
sendFileParamsFileInfoCallsCountLock.withLock { sendFileParamsFileInfoUnderlyingCallsCount += 1 }
|
|
sendFileParamsFileInfoReceivedArguments = (params: params, fileInfo: fileInfo)
|
|
sendFileParamsFileInfoReceivedInvocationsLock.withLock { sendFileParamsFileInfoUnderlyingReceivedInvocations.append((params: params, fileInfo: fileInfo)) }
|
|
if let sendFileParamsFileInfoClosure = sendFileParamsFileInfoClosure {
|
|
return try sendFileParamsFileInfoClosure(params, fileInfo)
|
|
} else {
|
|
return sendFileParamsFileInfoReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - sendImage
|
|
|
|
open var sendImageParamsThumbnailSourceImageInfoThrowableError: Error?
|
|
private let sendImageParamsThumbnailSourceImageInfoCallsCountLock = NSLock()
|
|
private var sendImageParamsThumbnailSourceImageInfoUnderlyingCallsCount = 0
|
|
open var sendImageParamsThumbnailSourceImageInfoCallsCount: Int {
|
|
get { sendImageParamsThumbnailSourceImageInfoCallsCountLock.withLock { sendImageParamsThumbnailSourceImageInfoUnderlyingCallsCount } }
|
|
set { sendImageParamsThumbnailSourceImageInfoCallsCountLock.withLock { sendImageParamsThumbnailSourceImageInfoUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var sendImageParamsThumbnailSourceImageInfoCalled: Bool {
|
|
return sendImageParamsThumbnailSourceImageInfoCallsCount > 0
|
|
}
|
|
private let sendImageParamsThumbnailSourceImageInfoReceivedArgumentsLock = NSLock()
|
|
private var sendImageParamsThumbnailSourceImageInfoUnderlyingReceivedArguments: (params: UploadParameters, thumbnailSource: UploadSource?, imageInfo: ImageInfo)?
|
|
open var sendImageParamsThumbnailSourceImageInfoReceivedArguments: (params: UploadParameters, thumbnailSource: UploadSource?, imageInfo: ImageInfo)? {
|
|
get { sendImageParamsThumbnailSourceImageInfoReceivedArgumentsLock.withLock { sendImageParamsThumbnailSourceImageInfoUnderlyingReceivedArguments } }
|
|
set { sendImageParamsThumbnailSourceImageInfoReceivedArgumentsLock.withLock { sendImageParamsThumbnailSourceImageInfoUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let sendImageParamsThumbnailSourceImageInfoReceivedInvocationsLock = NSLock()
|
|
private var sendImageParamsThumbnailSourceImageInfoUnderlyingReceivedInvocations: [(params: UploadParameters, thumbnailSource: UploadSource?, imageInfo: ImageInfo)] = []
|
|
open var sendImageParamsThumbnailSourceImageInfoReceivedInvocations: [(params: UploadParameters, thumbnailSource: UploadSource?, imageInfo: ImageInfo)] {
|
|
get { sendImageParamsThumbnailSourceImageInfoReceivedInvocationsLock.withLock { sendImageParamsThumbnailSourceImageInfoUnderlyingReceivedInvocations } }
|
|
set { sendImageParamsThumbnailSourceImageInfoReceivedInvocationsLock.withLock { sendImageParamsThumbnailSourceImageInfoUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let sendImageParamsThumbnailSourceImageInfoReturnValueLock = NSLock()
|
|
open var sendImageParamsThumbnailSourceImageInfoUnderlyingReturnValue: SendAttachmentJoinHandle!
|
|
open var sendImageParamsThumbnailSourceImageInfoReturnValue: SendAttachmentJoinHandle! {
|
|
get { sendImageParamsThumbnailSourceImageInfoReturnValueLock.withLock { sendImageParamsThumbnailSourceImageInfoUnderlyingReturnValue } }
|
|
set { sendImageParamsThumbnailSourceImageInfoReturnValueLock.withLock { sendImageParamsThumbnailSourceImageInfoUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var sendImageParamsThumbnailSourceImageInfoClosure: ((UploadParameters, UploadSource?, ImageInfo) throws -> SendAttachmentJoinHandle)?
|
|
|
|
open override func sendImage(params: UploadParameters, thumbnailSource: UploadSource?, imageInfo: ImageInfo) throws -> SendAttachmentJoinHandle {
|
|
if let error = sendImageParamsThumbnailSourceImageInfoThrowableError {
|
|
throw error
|
|
}
|
|
sendImageParamsThumbnailSourceImageInfoCallsCountLock.withLock { sendImageParamsThumbnailSourceImageInfoUnderlyingCallsCount += 1 }
|
|
sendImageParamsThumbnailSourceImageInfoReceivedArguments = (params: params, thumbnailSource: thumbnailSource, imageInfo: imageInfo)
|
|
sendImageParamsThumbnailSourceImageInfoReceivedInvocationsLock.withLock { sendImageParamsThumbnailSourceImageInfoUnderlyingReceivedInvocations.append((params: params, thumbnailSource: thumbnailSource, imageInfo: imageInfo)) }
|
|
if let sendImageParamsThumbnailSourceImageInfoClosure = sendImageParamsThumbnailSourceImageInfoClosure {
|
|
return try sendImageParamsThumbnailSourceImageInfoClosure(params, thumbnailSource, imageInfo)
|
|
} else {
|
|
return sendImageParamsThumbnailSourceImageInfoReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - sendLocation
|
|
|
|
open var sendLocationBodyGeoUriDescriptionZoomLevelAssetTypeRepliedToEventIdThrowableError: Error?
|
|
private let sendLocationBodyGeoUriDescriptionZoomLevelAssetTypeRepliedToEventIdCallsCountLock = NSLock()
|
|
private var sendLocationBodyGeoUriDescriptionZoomLevelAssetTypeRepliedToEventIdUnderlyingCallsCount = 0
|
|
open var sendLocationBodyGeoUriDescriptionZoomLevelAssetTypeRepliedToEventIdCallsCount: Int {
|
|
get { sendLocationBodyGeoUriDescriptionZoomLevelAssetTypeRepliedToEventIdCallsCountLock.withLock { sendLocationBodyGeoUriDescriptionZoomLevelAssetTypeRepliedToEventIdUnderlyingCallsCount } }
|
|
set { sendLocationBodyGeoUriDescriptionZoomLevelAssetTypeRepliedToEventIdCallsCountLock.withLock { sendLocationBodyGeoUriDescriptionZoomLevelAssetTypeRepliedToEventIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var sendLocationBodyGeoUriDescriptionZoomLevelAssetTypeRepliedToEventIdCalled: Bool {
|
|
return sendLocationBodyGeoUriDescriptionZoomLevelAssetTypeRepliedToEventIdCallsCount > 0
|
|
}
|
|
private let sendLocationBodyGeoUriDescriptionZoomLevelAssetTypeRepliedToEventIdReceivedArgumentsLock = NSLock()
|
|
private var sendLocationBodyGeoUriDescriptionZoomLevelAssetTypeRepliedToEventIdUnderlyingReceivedArguments: (body: String, geoUri: String, description: String?, zoomLevel: UInt8?, assetType: AssetType?, repliedToEventId: String?)?
|
|
open var sendLocationBodyGeoUriDescriptionZoomLevelAssetTypeRepliedToEventIdReceivedArguments: (body: String, geoUri: String, description: String?, zoomLevel: UInt8?, assetType: AssetType?, repliedToEventId: String?)? {
|
|
get { sendLocationBodyGeoUriDescriptionZoomLevelAssetTypeRepliedToEventIdReceivedArgumentsLock.withLock { sendLocationBodyGeoUriDescriptionZoomLevelAssetTypeRepliedToEventIdUnderlyingReceivedArguments } }
|
|
set { sendLocationBodyGeoUriDescriptionZoomLevelAssetTypeRepliedToEventIdReceivedArgumentsLock.withLock { sendLocationBodyGeoUriDescriptionZoomLevelAssetTypeRepliedToEventIdUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let sendLocationBodyGeoUriDescriptionZoomLevelAssetTypeRepliedToEventIdReceivedInvocationsLock = NSLock()
|
|
private var sendLocationBodyGeoUriDescriptionZoomLevelAssetTypeRepliedToEventIdUnderlyingReceivedInvocations: [(body: String, geoUri: String, description: String?, zoomLevel: UInt8?, assetType: AssetType?, repliedToEventId: String?)] = []
|
|
open var sendLocationBodyGeoUriDescriptionZoomLevelAssetTypeRepliedToEventIdReceivedInvocations: [(body: String, geoUri: String, description: String?, zoomLevel: UInt8?, assetType: AssetType?, repliedToEventId: String?)] {
|
|
get { sendLocationBodyGeoUriDescriptionZoomLevelAssetTypeRepliedToEventIdReceivedInvocationsLock.withLock { sendLocationBodyGeoUriDescriptionZoomLevelAssetTypeRepliedToEventIdUnderlyingReceivedInvocations } }
|
|
set { sendLocationBodyGeoUriDescriptionZoomLevelAssetTypeRepliedToEventIdReceivedInvocationsLock.withLock { sendLocationBodyGeoUriDescriptionZoomLevelAssetTypeRepliedToEventIdUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var sendLocationBodyGeoUriDescriptionZoomLevelAssetTypeRepliedToEventIdClosure: ((String, String, String?, UInt8?, AssetType?, String?) async throws -> Void)?
|
|
|
|
open override func sendLocation(body: String, geoUri: String, description: String?, zoomLevel: UInt8?, assetType: AssetType?, repliedToEventId: String?) async throws {
|
|
if let error = sendLocationBodyGeoUriDescriptionZoomLevelAssetTypeRepliedToEventIdThrowableError {
|
|
throw error
|
|
}
|
|
sendLocationBodyGeoUriDescriptionZoomLevelAssetTypeRepliedToEventIdCallsCountLock.withLock { sendLocationBodyGeoUriDescriptionZoomLevelAssetTypeRepliedToEventIdUnderlyingCallsCount += 1 }
|
|
sendLocationBodyGeoUriDescriptionZoomLevelAssetTypeRepliedToEventIdReceivedArguments = (body: body, geoUri: geoUri, description: description, zoomLevel: zoomLevel, assetType: assetType, repliedToEventId: repliedToEventId)
|
|
sendLocationBodyGeoUriDescriptionZoomLevelAssetTypeRepliedToEventIdReceivedInvocationsLock.withLock { sendLocationBodyGeoUriDescriptionZoomLevelAssetTypeRepliedToEventIdUnderlyingReceivedInvocations.append((body: body, geoUri: geoUri, description: description, zoomLevel: zoomLevel, assetType: assetType, repliedToEventId: repliedToEventId)) }
|
|
try await sendLocationBodyGeoUriDescriptionZoomLevelAssetTypeRepliedToEventIdClosure?(body, geoUri, description, zoomLevel, assetType, repliedToEventId)
|
|
}
|
|
|
|
//MARK: - sendPollResponse
|
|
|
|
open var sendPollResponsePollStartEventIdAnswersThrowableError: Error?
|
|
private let sendPollResponsePollStartEventIdAnswersCallsCountLock = NSLock()
|
|
private var sendPollResponsePollStartEventIdAnswersUnderlyingCallsCount = 0
|
|
open var sendPollResponsePollStartEventIdAnswersCallsCount: Int {
|
|
get { sendPollResponsePollStartEventIdAnswersCallsCountLock.withLock { sendPollResponsePollStartEventIdAnswersUnderlyingCallsCount } }
|
|
set { sendPollResponsePollStartEventIdAnswersCallsCountLock.withLock { sendPollResponsePollStartEventIdAnswersUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var sendPollResponsePollStartEventIdAnswersCalled: Bool {
|
|
return sendPollResponsePollStartEventIdAnswersCallsCount > 0
|
|
}
|
|
private let sendPollResponsePollStartEventIdAnswersReceivedArgumentsLock = NSLock()
|
|
private var sendPollResponsePollStartEventIdAnswersUnderlyingReceivedArguments: (pollStartEventId: String, answers: [String])?
|
|
open var sendPollResponsePollStartEventIdAnswersReceivedArguments: (pollStartEventId: String, answers: [String])? {
|
|
get { sendPollResponsePollStartEventIdAnswersReceivedArgumentsLock.withLock { sendPollResponsePollStartEventIdAnswersUnderlyingReceivedArguments } }
|
|
set { sendPollResponsePollStartEventIdAnswersReceivedArgumentsLock.withLock { sendPollResponsePollStartEventIdAnswersUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let sendPollResponsePollStartEventIdAnswersReceivedInvocationsLock = NSLock()
|
|
private var sendPollResponsePollStartEventIdAnswersUnderlyingReceivedInvocations: [(pollStartEventId: String, answers: [String])] = []
|
|
open var sendPollResponsePollStartEventIdAnswersReceivedInvocations: [(pollStartEventId: String, answers: [String])] {
|
|
get { sendPollResponsePollStartEventIdAnswersReceivedInvocationsLock.withLock { sendPollResponsePollStartEventIdAnswersUnderlyingReceivedInvocations } }
|
|
set { sendPollResponsePollStartEventIdAnswersReceivedInvocationsLock.withLock { sendPollResponsePollStartEventIdAnswersUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var sendPollResponsePollStartEventIdAnswersClosure: ((String, [String]) async throws -> Void)?
|
|
|
|
open override func sendPollResponse(pollStartEventId: String, answers: [String]) async throws {
|
|
if let error = sendPollResponsePollStartEventIdAnswersThrowableError {
|
|
throw error
|
|
}
|
|
sendPollResponsePollStartEventIdAnswersCallsCountLock.withLock { sendPollResponsePollStartEventIdAnswersUnderlyingCallsCount += 1 }
|
|
sendPollResponsePollStartEventIdAnswersReceivedArguments = (pollStartEventId: pollStartEventId, answers: answers)
|
|
sendPollResponsePollStartEventIdAnswersReceivedInvocationsLock.withLock { sendPollResponsePollStartEventIdAnswersUnderlyingReceivedInvocations.append((pollStartEventId: pollStartEventId, answers: answers)) }
|
|
try await sendPollResponsePollStartEventIdAnswersClosure?(pollStartEventId, answers)
|
|
}
|
|
|
|
//MARK: - sendReadReceipt
|
|
|
|
open var sendReadReceiptReceiptTypeEventIdThrowableError: Error?
|
|
private let sendReadReceiptReceiptTypeEventIdCallsCountLock = NSLock()
|
|
private var sendReadReceiptReceiptTypeEventIdUnderlyingCallsCount = 0
|
|
open var sendReadReceiptReceiptTypeEventIdCallsCount: Int {
|
|
get { sendReadReceiptReceiptTypeEventIdCallsCountLock.withLock { sendReadReceiptReceiptTypeEventIdUnderlyingCallsCount } }
|
|
set { sendReadReceiptReceiptTypeEventIdCallsCountLock.withLock { sendReadReceiptReceiptTypeEventIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var sendReadReceiptReceiptTypeEventIdCalled: Bool {
|
|
return sendReadReceiptReceiptTypeEventIdCallsCount > 0
|
|
}
|
|
private let sendReadReceiptReceiptTypeEventIdReceivedArgumentsLock = NSLock()
|
|
private var sendReadReceiptReceiptTypeEventIdUnderlyingReceivedArguments: (receiptType: ReceiptType, eventId: String)?
|
|
open var sendReadReceiptReceiptTypeEventIdReceivedArguments: (receiptType: ReceiptType, eventId: String)? {
|
|
get { sendReadReceiptReceiptTypeEventIdReceivedArgumentsLock.withLock { sendReadReceiptReceiptTypeEventIdUnderlyingReceivedArguments } }
|
|
set { sendReadReceiptReceiptTypeEventIdReceivedArgumentsLock.withLock { sendReadReceiptReceiptTypeEventIdUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let sendReadReceiptReceiptTypeEventIdReceivedInvocationsLock = NSLock()
|
|
private var sendReadReceiptReceiptTypeEventIdUnderlyingReceivedInvocations: [(receiptType: ReceiptType, eventId: String)] = []
|
|
open var sendReadReceiptReceiptTypeEventIdReceivedInvocations: [(receiptType: ReceiptType, eventId: String)] {
|
|
get { sendReadReceiptReceiptTypeEventIdReceivedInvocationsLock.withLock { sendReadReceiptReceiptTypeEventIdUnderlyingReceivedInvocations } }
|
|
set { sendReadReceiptReceiptTypeEventIdReceivedInvocationsLock.withLock { sendReadReceiptReceiptTypeEventIdUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var sendReadReceiptReceiptTypeEventIdClosure: ((ReceiptType, String) async throws -> Void)?
|
|
|
|
open override func sendReadReceipt(receiptType: ReceiptType, eventId: String) async throws {
|
|
if let error = sendReadReceiptReceiptTypeEventIdThrowableError {
|
|
throw error
|
|
}
|
|
sendReadReceiptReceiptTypeEventIdCallsCountLock.withLock { sendReadReceiptReceiptTypeEventIdUnderlyingCallsCount += 1 }
|
|
sendReadReceiptReceiptTypeEventIdReceivedArguments = (receiptType: receiptType, eventId: eventId)
|
|
sendReadReceiptReceiptTypeEventIdReceivedInvocationsLock.withLock { sendReadReceiptReceiptTypeEventIdUnderlyingReceivedInvocations.append((receiptType: receiptType, eventId: eventId)) }
|
|
try await sendReadReceiptReceiptTypeEventIdClosure?(receiptType, eventId)
|
|
}
|
|
|
|
//MARK: - sendReply
|
|
|
|
open var sendReplyMsgEventIdThrowableError: Error?
|
|
private let sendReplyMsgEventIdCallsCountLock = NSLock()
|
|
private var sendReplyMsgEventIdUnderlyingCallsCount = 0
|
|
open var sendReplyMsgEventIdCallsCount: Int {
|
|
get { sendReplyMsgEventIdCallsCountLock.withLock { sendReplyMsgEventIdUnderlyingCallsCount } }
|
|
set { sendReplyMsgEventIdCallsCountLock.withLock { sendReplyMsgEventIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var sendReplyMsgEventIdCalled: Bool {
|
|
return sendReplyMsgEventIdCallsCount > 0
|
|
}
|
|
private let sendReplyMsgEventIdReceivedArgumentsLock = NSLock()
|
|
private var sendReplyMsgEventIdUnderlyingReceivedArguments: (msg: RoomMessageEventContentWithoutRelation, eventId: String)?
|
|
open var sendReplyMsgEventIdReceivedArguments: (msg: RoomMessageEventContentWithoutRelation, eventId: String)? {
|
|
get { sendReplyMsgEventIdReceivedArgumentsLock.withLock { sendReplyMsgEventIdUnderlyingReceivedArguments } }
|
|
set { sendReplyMsgEventIdReceivedArgumentsLock.withLock { sendReplyMsgEventIdUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let sendReplyMsgEventIdReceivedInvocationsLock = NSLock()
|
|
private var sendReplyMsgEventIdUnderlyingReceivedInvocations: [(msg: RoomMessageEventContentWithoutRelation, eventId: String)] = []
|
|
open var sendReplyMsgEventIdReceivedInvocations: [(msg: RoomMessageEventContentWithoutRelation, eventId: String)] {
|
|
get { sendReplyMsgEventIdReceivedInvocationsLock.withLock { sendReplyMsgEventIdUnderlyingReceivedInvocations } }
|
|
set { sendReplyMsgEventIdReceivedInvocationsLock.withLock { sendReplyMsgEventIdUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var sendReplyMsgEventIdClosure: ((RoomMessageEventContentWithoutRelation, String) async throws -> Void)?
|
|
|
|
open override func sendReply(msg: RoomMessageEventContentWithoutRelation, eventId: String) async throws {
|
|
if let error = sendReplyMsgEventIdThrowableError {
|
|
throw error
|
|
}
|
|
sendReplyMsgEventIdCallsCountLock.withLock { sendReplyMsgEventIdUnderlyingCallsCount += 1 }
|
|
sendReplyMsgEventIdReceivedArguments = (msg: msg, eventId: eventId)
|
|
sendReplyMsgEventIdReceivedInvocationsLock.withLock { sendReplyMsgEventIdUnderlyingReceivedInvocations.append((msg: msg, eventId: eventId)) }
|
|
try await sendReplyMsgEventIdClosure?(msg, eventId)
|
|
}
|
|
|
|
//MARK: - sendVideo
|
|
|
|
open var sendVideoParamsThumbnailSourceVideoInfoThrowableError: Error?
|
|
private let sendVideoParamsThumbnailSourceVideoInfoCallsCountLock = NSLock()
|
|
private var sendVideoParamsThumbnailSourceVideoInfoUnderlyingCallsCount = 0
|
|
open var sendVideoParamsThumbnailSourceVideoInfoCallsCount: Int {
|
|
get { sendVideoParamsThumbnailSourceVideoInfoCallsCountLock.withLock { sendVideoParamsThumbnailSourceVideoInfoUnderlyingCallsCount } }
|
|
set { sendVideoParamsThumbnailSourceVideoInfoCallsCountLock.withLock { sendVideoParamsThumbnailSourceVideoInfoUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var sendVideoParamsThumbnailSourceVideoInfoCalled: Bool {
|
|
return sendVideoParamsThumbnailSourceVideoInfoCallsCount > 0
|
|
}
|
|
private let sendVideoParamsThumbnailSourceVideoInfoReceivedArgumentsLock = NSLock()
|
|
private var sendVideoParamsThumbnailSourceVideoInfoUnderlyingReceivedArguments: (params: UploadParameters, thumbnailSource: UploadSource?, videoInfo: VideoInfo)?
|
|
open var sendVideoParamsThumbnailSourceVideoInfoReceivedArguments: (params: UploadParameters, thumbnailSource: UploadSource?, videoInfo: VideoInfo)? {
|
|
get { sendVideoParamsThumbnailSourceVideoInfoReceivedArgumentsLock.withLock { sendVideoParamsThumbnailSourceVideoInfoUnderlyingReceivedArguments } }
|
|
set { sendVideoParamsThumbnailSourceVideoInfoReceivedArgumentsLock.withLock { sendVideoParamsThumbnailSourceVideoInfoUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let sendVideoParamsThumbnailSourceVideoInfoReceivedInvocationsLock = NSLock()
|
|
private var sendVideoParamsThumbnailSourceVideoInfoUnderlyingReceivedInvocations: [(params: UploadParameters, thumbnailSource: UploadSource?, videoInfo: VideoInfo)] = []
|
|
open var sendVideoParamsThumbnailSourceVideoInfoReceivedInvocations: [(params: UploadParameters, thumbnailSource: UploadSource?, videoInfo: VideoInfo)] {
|
|
get { sendVideoParamsThumbnailSourceVideoInfoReceivedInvocationsLock.withLock { sendVideoParamsThumbnailSourceVideoInfoUnderlyingReceivedInvocations } }
|
|
set { sendVideoParamsThumbnailSourceVideoInfoReceivedInvocationsLock.withLock { sendVideoParamsThumbnailSourceVideoInfoUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let sendVideoParamsThumbnailSourceVideoInfoReturnValueLock = NSLock()
|
|
open var sendVideoParamsThumbnailSourceVideoInfoUnderlyingReturnValue: SendAttachmentJoinHandle!
|
|
open var sendVideoParamsThumbnailSourceVideoInfoReturnValue: SendAttachmentJoinHandle! {
|
|
get { sendVideoParamsThumbnailSourceVideoInfoReturnValueLock.withLock { sendVideoParamsThumbnailSourceVideoInfoUnderlyingReturnValue } }
|
|
set { sendVideoParamsThumbnailSourceVideoInfoReturnValueLock.withLock { sendVideoParamsThumbnailSourceVideoInfoUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var sendVideoParamsThumbnailSourceVideoInfoClosure: ((UploadParameters, UploadSource?, VideoInfo) throws -> SendAttachmentJoinHandle)?
|
|
|
|
open override func sendVideo(params: UploadParameters, thumbnailSource: UploadSource?, videoInfo: VideoInfo) throws -> SendAttachmentJoinHandle {
|
|
if let error = sendVideoParamsThumbnailSourceVideoInfoThrowableError {
|
|
throw error
|
|
}
|
|
sendVideoParamsThumbnailSourceVideoInfoCallsCountLock.withLock { sendVideoParamsThumbnailSourceVideoInfoUnderlyingCallsCount += 1 }
|
|
sendVideoParamsThumbnailSourceVideoInfoReceivedArguments = (params: params, thumbnailSource: thumbnailSource, videoInfo: videoInfo)
|
|
sendVideoParamsThumbnailSourceVideoInfoReceivedInvocationsLock.withLock { sendVideoParamsThumbnailSourceVideoInfoUnderlyingReceivedInvocations.append((params: params, thumbnailSource: thumbnailSource, videoInfo: videoInfo)) }
|
|
if let sendVideoParamsThumbnailSourceVideoInfoClosure = sendVideoParamsThumbnailSourceVideoInfoClosure {
|
|
return try sendVideoParamsThumbnailSourceVideoInfoClosure(params, thumbnailSource, videoInfo)
|
|
} else {
|
|
return sendVideoParamsThumbnailSourceVideoInfoReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - sendVoiceMessage
|
|
|
|
open var sendVoiceMessageParamsAudioInfoWaveformThrowableError: Error?
|
|
private let sendVoiceMessageParamsAudioInfoWaveformCallsCountLock = NSLock()
|
|
private var sendVoiceMessageParamsAudioInfoWaveformUnderlyingCallsCount = 0
|
|
open var sendVoiceMessageParamsAudioInfoWaveformCallsCount: Int {
|
|
get { sendVoiceMessageParamsAudioInfoWaveformCallsCountLock.withLock { sendVoiceMessageParamsAudioInfoWaveformUnderlyingCallsCount } }
|
|
set { sendVoiceMessageParamsAudioInfoWaveformCallsCountLock.withLock { sendVoiceMessageParamsAudioInfoWaveformUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var sendVoiceMessageParamsAudioInfoWaveformCalled: Bool {
|
|
return sendVoiceMessageParamsAudioInfoWaveformCallsCount > 0
|
|
}
|
|
private let sendVoiceMessageParamsAudioInfoWaveformReceivedArgumentsLock = NSLock()
|
|
private var sendVoiceMessageParamsAudioInfoWaveformUnderlyingReceivedArguments: (params: UploadParameters, audioInfo: AudioInfo, waveform: [Float])?
|
|
open var sendVoiceMessageParamsAudioInfoWaveformReceivedArguments: (params: UploadParameters, audioInfo: AudioInfo, waveform: [Float])? {
|
|
get { sendVoiceMessageParamsAudioInfoWaveformReceivedArgumentsLock.withLock { sendVoiceMessageParamsAudioInfoWaveformUnderlyingReceivedArguments } }
|
|
set { sendVoiceMessageParamsAudioInfoWaveformReceivedArgumentsLock.withLock { sendVoiceMessageParamsAudioInfoWaveformUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let sendVoiceMessageParamsAudioInfoWaveformReceivedInvocationsLock = NSLock()
|
|
private var sendVoiceMessageParamsAudioInfoWaveformUnderlyingReceivedInvocations: [(params: UploadParameters, audioInfo: AudioInfo, waveform: [Float])] = []
|
|
open var sendVoiceMessageParamsAudioInfoWaveformReceivedInvocations: [(params: UploadParameters, audioInfo: AudioInfo, waveform: [Float])] {
|
|
get { sendVoiceMessageParamsAudioInfoWaveformReceivedInvocationsLock.withLock { sendVoiceMessageParamsAudioInfoWaveformUnderlyingReceivedInvocations } }
|
|
set { sendVoiceMessageParamsAudioInfoWaveformReceivedInvocationsLock.withLock { sendVoiceMessageParamsAudioInfoWaveformUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let sendVoiceMessageParamsAudioInfoWaveformReturnValueLock = NSLock()
|
|
open var sendVoiceMessageParamsAudioInfoWaveformUnderlyingReturnValue: SendAttachmentJoinHandle!
|
|
open var sendVoiceMessageParamsAudioInfoWaveformReturnValue: SendAttachmentJoinHandle! {
|
|
get { sendVoiceMessageParamsAudioInfoWaveformReturnValueLock.withLock { sendVoiceMessageParamsAudioInfoWaveformUnderlyingReturnValue } }
|
|
set { sendVoiceMessageParamsAudioInfoWaveformReturnValueLock.withLock { sendVoiceMessageParamsAudioInfoWaveformUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var sendVoiceMessageParamsAudioInfoWaveformClosure: ((UploadParameters, AudioInfo, [Float]) throws -> SendAttachmentJoinHandle)?
|
|
|
|
open override func sendVoiceMessage(params: UploadParameters, audioInfo: AudioInfo, waveform: [Float]) throws -> SendAttachmentJoinHandle {
|
|
if let error = sendVoiceMessageParamsAudioInfoWaveformThrowableError {
|
|
throw error
|
|
}
|
|
sendVoiceMessageParamsAudioInfoWaveformCallsCountLock.withLock { sendVoiceMessageParamsAudioInfoWaveformUnderlyingCallsCount += 1 }
|
|
sendVoiceMessageParamsAudioInfoWaveformReceivedArguments = (params: params, audioInfo: audioInfo, waveform: waveform)
|
|
sendVoiceMessageParamsAudioInfoWaveformReceivedInvocationsLock.withLock { sendVoiceMessageParamsAudioInfoWaveformUnderlyingReceivedInvocations.append((params: params, audioInfo: audioInfo, waveform: waveform)) }
|
|
if let sendVoiceMessageParamsAudioInfoWaveformClosure = sendVoiceMessageParamsAudioInfoWaveformClosure {
|
|
return try sendVoiceMessageParamsAudioInfoWaveformClosure(params, audioInfo, waveform)
|
|
} else {
|
|
return sendVoiceMessageParamsAudioInfoWaveformReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - subscribeToBackPaginationStatus
|
|
|
|
open var subscribeToBackPaginationStatusListenerThrowableError: Error?
|
|
private let subscribeToBackPaginationStatusListenerCallsCountLock = NSLock()
|
|
private var subscribeToBackPaginationStatusListenerUnderlyingCallsCount = 0
|
|
open var subscribeToBackPaginationStatusListenerCallsCount: Int {
|
|
get { subscribeToBackPaginationStatusListenerCallsCountLock.withLock { subscribeToBackPaginationStatusListenerUnderlyingCallsCount } }
|
|
set { subscribeToBackPaginationStatusListenerCallsCountLock.withLock { subscribeToBackPaginationStatusListenerUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var subscribeToBackPaginationStatusListenerCalled: Bool {
|
|
return subscribeToBackPaginationStatusListenerCallsCount > 0
|
|
}
|
|
private let subscribeToBackPaginationStatusListenerReceivedListenerLock = NSLock()
|
|
private var subscribeToBackPaginationStatusListenerUnderlyingReceivedListener: PaginationStatusListener?
|
|
open var subscribeToBackPaginationStatusListenerReceivedListener: PaginationStatusListener? {
|
|
get { subscribeToBackPaginationStatusListenerReceivedListenerLock.withLock { subscribeToBackPaginationStatusListenerUnderlyingReceivedListener } }
|
|
set { subscribeToBackPaginationStatusListenerReceivedListenerLock.withLock { subscribeToBackPaginationStatusListenerUnderlyingReceivedListener = newValue } }
|
|
}
|
|
private let subscribeToBackPaginationStatusListenerReceivedInvocationsLock = NSLock()
|
|
private var subscribeToBackPaginationStatusListenerUnderlyingReceivedInvocations: [PaginationStatusListener] = []
|
|
open var subscribeToBackPaginationStatusListenerReceivedInvocations: [PaginationStatusListener] {
|
|
get { subscribeToBackPaginationStatusListenerReceivedInvocationsLock.withLock { subscribeToBackPaginationStatusListenerUnderlyingReceivedInvocations } }
|
|
set { subscribeToBackPaginationStatusListenerReceivedInvocationsLock.withLock { subscribeToBackPaginationStatusListenerUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let subscribeToBackPaginationStatusListenerReturnValueLock = NSLock()
|
|
open var subscribeToBackPaginationStatusListenerUnderlyingReturnValue: TaskHandle!
|
|
open var subscribeToBackPaginationStatusListenerReturnValue: TaskHandle! {
|
|
get { subscribeToBackPaginationStatusListenerReturnValueLock.withLock { subscribeToBackPaginationStatusListenerUnderlyingReturnValue } }
|
|
set { subscribeToBackPaginationStatusListenerReturnValueLock.withLock { subscribeToBackPaginationStatusListenerUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var subscribeToBackPaginationStatusListenerClosure: ((PaginationStatusListener) async throws -> TaskHandle)?
|
|
|
|
open override func subscribeToBackPaginationStatus(listener: PaginationStatusListener) async throws -> TaskHandle {
|
|
if let error = subscribeToBackPaginationStatusListenerThrowableError {
|
|
throw error
|
|
}
|
|
subscribeToBackPaginationStatusListenerCallsCountLock.withLock { subscribeToBackPaginationStatusListenerUnderlyingCallsCount += 1 }
|
|
subscribeToBackPaginationStatusListenerReceivedListener = listener
|
|
subscribeToBackPaginationStatusListenerReceivedInvocationsLock.withLock { subscribeToBackPaginationStatusListenerUnderlyingReceivedInvocations.append(listener) }
|
|
if let subscribeToBackPaginationStatusListenerClosure = subscribeToBackPaginationStatusListenerClosure {
|
|
return try await subscribeToBackPaginationStatusListenerClosure(listener)
|
|
} else {
|
|
return subscribeToBackPaginationStatusListenerReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - toggleReaction
|
|
|
|
open var toggleReactionItemIdKeyThrowableError: Error?
|
|
private let toggleReactionItemIdKeyCallsCountLock = NSLock()
|
|
private var toggleReactionItemIdKeyUnderlyingCallsCount = 0
|
|
open var toggleReactionItemIdKeyCallsCount: Int {
|
|
get { toggleReactionItemIdKeyCallsCountLock.withLock { toggleReactionItemIdKeyUnderlyingCallsCount } }
|
|
set { toggleReactionItemIdKeyCallsCountLock.withLock { toggleReactionItemIdKeyUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var toggleReactionItemIdKeyCalled: Bool {
|
|
return toggleReactionItemIdKeyCallsCount > 0
|
|
}
|
|
private let toggleReactionItemIdKeyReceivedArgumentsLock = NSLock()
|
|
private var toggleReactionItemIdKeyUnderlyingReceivedArguments: (itemId: EventOrTransactionId, key: String)?
|
|
open var toggleReactionItemIdKeyReceivedArguments: (itemId: EventOrTransactionId, key: String)? {
|
|
get { toggleReactionItemIdKeyReceivedArgumentsLock.withLock { toggleReactionItemIdKeyUnderlyingReceivedArguments } }
|
|
set { toggleReactionItemIdKeyReceivedArgumentsLock.withLock { toggleReactionItemIdKeyUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let toggleReactionItemIdKeyReceivedInvocationsLock = NSLock()
|
|
private var toggleReactionItemIdKeyUnderlyingReceivedInvocations: [(itemId: EventOrTransactionId, key: String)] = []
|
|
open var toggleReactionItemIdKeyReceivedInvocations: [(itemId: EventOrTransactionId, key: String)] {
|
|
get { toggleReactionItemIdKeyReceivedInvocationsLock.withLock { toggleReactionItemIdKeyUnderlyingReceivedInvocations } }
|
|
set { toggleReactionItemIdKeyReceivedInvocationsLock.withLock { toggleReactionItemIdKeyUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let toggleReactionItemIdKeyReturnValueLock = NSLock()
|
|
open var toggleReactionItemIdKeyUnderlyingReturnValue: Bool!
|
|
open var toggleReactionItemIdKeyReturnValue: Bool! {
|
|
get { toggleReactionItemIdKeyReturnValueLock.withLock { toggleReactionItemIdKeyUnderlyingReturnValue } }
|
|
set { toggleReactionItemIdKeyReturnValueLock.withLock { toggleReactionItemIdKeyUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var toggleReactionItemIdKeyClosure: ((EventOrTransactionId, String) async throws -> Bool)?
|
|
|
|
open override func toggleReaction(itemId: EventOrTransactionId, key: String) async throws -> Bool {
|
|
if let error = toggleReactionItemIdKeyThrowableError {
|
|
throw error
|
|
}
|
|
toggleReactionItemIdKeyCallsCountLock.withLock { toggleReactionItemIdKeyUnderlyingCallsCount += 1 }
|
|
toggleReactionItemIdKeyReceivedArguments = (itemId: itemId, key: key)
|
|
toggleReactionItemIdKeyReceivedInvocationsLock.withLock { toggleReactionItemIdKeyUnderlyingReceivedInvocations.append((itemId: itemId, key: key)) }
|
|
if let toggleReactionItemIdKeyClosure = toggleReactionItemIdKeyClosure {
|
|
return try await toggleReactionItemIdKeyClosure(itemId, key)
|
|
} else {
|
|
return toggleReactionItemIdKeyReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - unpinEvent
|
|
|
|
open var unpinEventEventIdThrowableError: Error?
|
|
private let unpinEventEventIdCallsCountLock = NSLock()
|
|
private var unpinEventEventIdUnderlyingCallsCount = 0
|
|
open var unpinEventEventIdCallsCount: Int {
|
|
get { unpinEventEventIdCallsCountLock.withLock { unpinEventEventIdUnderlyingCallsCount } }
|
|
set { unpinEventEventIdCallsCountLock.withLock { unpinEventEventIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var unpinEventEventIdCalled: Bool {
|
|
return unpinEventEventIdCallsCount > 0
|
|
}
|
|
private let unpinEventEventIdReceivedEventIdLock = NSLock()
|
|
private var unpinEventEventIdUnderlyingReceivedEventId: String?
|
|
open var unpinEventEventIdReceivedEventId: String? {
|
|
get { unpinEventEventIdReceivedEventIdLock.withLock { unpinEventEventIdUnderlyingReceivedEventId } }
|
|
set { unpinEventEventIdReceivedEventIdLock.withLock { unpinEventEventIdUnderlyingReceivedEventId = newValue } }
|
|
}
|
|
private let unpinEventEventIdReceivedInvocationsLock = NSLock()
|
|
private var unpinEventEventIdUnderlyingReceivedInvocations: [String] = []
|
|
open var unpinEventEventIdReceivedInvocations: [String] {
|
|
get { unpinEventEventIdReceivedInvocationsLock.withLock { unpinEventEventIdUnderlyingReceivedInvocations } }
|
|
set { unpinEventEventIdReceivedInvocationsLock.withLock { unpinEventEventIdUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let unpinEventEventIdReturnValueLock = NSLock()
|
|
open var unpinEventEventIdUnderlyingReturnValue: Bool!
|
|
open var unpinEventEventIdReturnValue: Bool! {
|
|
get { unpinEventEventIdReturnValueLock.withLock { unpinEventEventIdUnderlyingReturnValue } }
|
|
set { unpinEventEventIdReturnValueLock.withLock { unpinEventEventIdUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var unpinEventEventIdClosure: ((String) async throws -> Bool)?
|
|
|
|
open override func unpinEvent(eventId: String) async throws -> Bool {
|
|
if let error = unpinEventEventIdThrowableError {
|
|
throw error
|
|
}
|
|
unpinEventEventIdCallsCountLock.withLock { unpinEventEventIdUnderlyingCallsCount += 1 }
|
|
unpinEventEventIdReceivedEventId = eventId
|
|
unpinEventEventIdReceivedInvocationsLock.withLock { unpinEventEventIdUnderlyingReceivedInvocations.append(eventId) }
|
|
if let unpinEventEventIdClosure = unpinEventEventIdClosure {
|
|
return try await unpinEventEventIdClosure(eventId)
|
|
} else {
|
|
return unpinEventEventIdReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - sendGallery
|
|
|
|
open var sendGalleryParamsItemInfosThrowableError: Error?
|
|
private let sendGalleryParamsItemInfosCallsCountLock = NSLock()
|
|
private var sendGalleryParamsItemInfosUnderlyingCallsCount = 0
|
|
open var sendGalleryParamsItemInfosCallsCount: Int {
|
|
get { sendGalleryParamsItemInfosCallsCountLock.withLock { sendGalleryParamsItemInfosUnderlyingCallsCount } }
|
|
set { sendGalleryParamsItemInfosCallsCountLock.withLock { sendGalleryParamsItemInfosUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var sendGalleryParamsItemInfosCalled: Bool {
|
|
return sendGalleryParamsItemInfosCallsCount > 0
|
|
}
|
|
private let sendGalleryParamsItemInfosReceivedArgumentsLock = NSLock()
|
|
private var sendGalleryParamsItemInfosUnderlyingReceivedArguments: (params: GalleryUploadParameters, itemInfos: [GalleryItemInfo])?
|
|
open var sendGalleryParamsItemInfosReceivedArguments: (params: GalleryUploadParameters, itemInfos: [GalleryItemInfo])? {
|
|
get { sendGalleryParamsItemInfosReceivedArgumentsLock.withLock { sendGalleryParamsItemInfosUnderlyingReceivedArguments } }
|
|
set { sendGalleryParamsItemInfosReceivedArgumentsLock.withLock { sendGalleryParamsItemInfosUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let sendGalleryParamsItemInfosReceivedInvocationsLock = NSLock()
|
|
private var sendGalleryParamsItemInfosUnderlyingReceivedInvocations: [(params: GalleryUploadParameters, itemInfos: [GalleryItemInfo])] = []
|
|
open var sendGalleryParamsItemInfosReceivedInvocations: [(params: GalleryUploadParameters, itemInfos: [GalleryItemInfo])] {
|
|
get { sendGalleryParamsItemInfosReceivedInvocationsLock.withLock { sendGalleryParamsItemInfosUnderlyingReceivedInvocations } }
|
|
set { sendGalleryParamsItemInfosReceivedInvocationsLock.withLock { sendGalleryParamsItemInfosUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let sendGalleryParamsItemInfosReturnValueLock = NSLock()
|
|
open var sendGalleryParamsItemInfosUnderlyingReturnValue: SendGalleryJoinHandle!
|
|
open var sendGalleryParamsItemInfosReturnValue: SendGalleryJoinHandle! {
|
|
get { sendGalleryParamsItemInfosReturnValueLock.withLock { sendGalleryParamsItemInfosUnderlyingReturnValue } }
|
|
set { sendGalleryParamsItemInfosReturnValueLock.withLock { sendGalleryParamsItemInfosUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var sendGalleryParamsItemInfosClosure: ((GalleryUploadParameters, [GalleryItemInfo]) throws -> SendGalleryJoinHandle)?
|
|
|
|
open override func sendGallery(params: GalleryUploadParameters, itemInfos: [GalleryItemInfo]) throws -> SendGalleryJoinHandle {
|
|
if let error = sendGalleryParamsItemInfosThrowableError {
|
|
throw error
|
|
}
|
|
sendGalleryParamsItemInfosCallsCountLock.withLock { sendGalleryParamsItemInfosUnderlyingCallsCount += 1 }
|
|
sendGalleryParamsItemInfosReceivedArguments = (params: params, itemInfos: itemInfos)
|
|
sendGalleryParamsItemInfosReceivedInvocationsLock.withLock { sendGalleryParamsItemInfosUnderlyingReceivedInvocations.append((params: params, itemInfos: itemInfos)) }
|
|
if let sendGalleryParamsItemInfosClosure = sendGalleryParamsItemInfosClosure {
|
|
return try sendGalleryParamsItemInfosClosure(params, itemInfos)
|
|
} else {
|
|
return sendGalleryParamsItemInfosReturnValue
|
|
}
|
|
}
|
|
}
|
|
open class TimelineEventSDKMock: MatrixRustSDK.TimelineEvent, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
|
|
//MARK: - content
|
|
|
|
open var contentThrowableError: Error?
|
|
private let contentCallsCountLock = NSLock()
|
|
private var contentUnderlyingCallsCount = 0
|
|
open var contentCallsCount: Int {
|
|
get { contentCallsCountLock.withLock { contentUnderlyingCallsCount } }
|
|
set { contentCallsCountLock.withLock { contentUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var contentCalled: Bool {
|
|
return contentCallsCount > 0
|
|
}
|
|
|
|
private let contentReturnValueLock = NSLock()
|
|
open var contentUnderlyingReturnValue: TimelineEventContent!
|
|
open var contentReturnValue: TimelineEventContent! {
|
|
get { contentReturnValueLock.withLock { contentUnderlyingReturnValue } }
|
|
set { contentReturnValueLock.withLock { contentUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var contentClosure: (() throws -> TimelineEventContent)?
|
|
|
|
open override func content() throws -> TimelineEventContent {
|
|
if let error = contentThrowableError {
|
|
throw error
|
|
}
|
|
contentCallsCountLock.withLock { contentUnderlyingCallsCount += 1 }
|
|
if let contentClosure = contentClosure {
|
|
return try contentClosure()
|
|
} else {
|
|
return contentReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - eventId
|
|
|
|
private let eventIdCallsCountLock = NSLock()
|
|
private var eventIdUnderlyingCallsCount = 0
|
|
open var eventIdCallsCount: Int {
|
|
get { eventIdCallsCountLock.withLock { eventIdUnderlyingCallsCount } }
|
|
set { eventIdCallsCountLock.withLock { eventIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var eventIdCalled: Bool {
|
|
return eventIdCallsCount > 0
|
|
}
|
|
|
|
private let eventIdReturnValueLock = NSLock()
|
|
open var eventIdUnderlyingReturnValue: String!
|
|
open var eventIdReturnValue: String! {
|
|
get { eventIdReturnValueLock.withLock { eventIdUnderlyingReturnValue } }
|
|
set { eventIdReturnValueLock.withLock { eventIdUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var eventIdClosure: (() -> String)?
|
|
|
|
open override func eventId() -> String {
|
|
eventIdCallsCountLock.withLock { eventIdUnderlyingCallsCount += 1 }
|
|
if let eventIdClosure = eventIdClosure {
|
|
return eventIdClosure()
|
|
} else {
|
|
return eventIdReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - senderId
|
|
|
|
private let senderIdCallsCountLock = NSLock()
|
|
private var senderIdUnderlyingCallsCount = 0
|
|
open var senderIdCallsCount: Int {
|
|
get { senderIdCallsCountLock.withLock { senderIdUnderlyingCallsCount } }
|
|
set { senderIdCallsCountLock.withLock { senderIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var senderIdCalled: Bool {
|
|
return senderIdCallsCount > 0
|
|
}
|
|
|
|
private let senderIdReturnValueLock = NSLock()
|
|
open var senderIdUnderlyingReturnValue: String!
|
|
open var senderIdReturnValue: String! {
|
|
get { senderIdReturnValueLock.withLock { senderIdUnderlyingReturnValue } }
|
|
set { senderIdReturnValueLock.withLock { senderIdUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var senderIdClosure: (() -> String)?
|
|
|
|
open override func senderId() -> String {
|
|
senderIdCallsCountLock.withLock { senderIdUnderlyingCallsCount += 1 }
|
|
if let senderIdClosure = senderIdClosure {
|
|
return senderIdClosure()
|
|
} else {
|
|
return senderIdReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - threadRootEventId
|
|
|
|
private let threadRootEventIdCallsCountLock = NSLock()
|
|
private var threadRootEventIdUnderlyingCallsCount = 0
|
|
open var threadRootEventIdCallsCount: Int {
|
|
get { threadRootEventIdCallsCountLock.withLock { threadRootEventIdUnderlyingCallsCount } }
|
|
set { threadRootEventIdCallsCountLock.withLock { threadRootEventIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var threadRootEventIdCalled: Bool {
|
|
return threadRootEventIdCallsCount > 0
|
|
}
|
|
|
|
private let threadRootEventIdReturnValueLock = NSLock()
|
|
open var threadRootEventIdUnderlyingReturnValue: String?
|
|
open var threadRootEventIdReturnValue: String? {
|
|
get { threadRootEventIdReturnValueLock.withLock { threadRootEventIdUnderlyingReturnValue } }
|
|
set { threadRootEventIdReturnValueLock.withLock { threadRootEventIdUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var threadRootEventIdClosure: (() -> String?)?
|
|
|
|
open override func threadRootEventId() -> String? {
|
|
threadRootEventIdCallsCountLock.withLock { threadRootEventIdUnderlyingCallsCount += 1 }
|
|
if let threadRootEventIdClosure = threadRootEventIdClosure {
|
|
return threadRootEventIdClosure()
|
|
} else {
|
|
return threadRootEventIdReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - timestamp
|
|
|
|
private let timestampCallsCountLock = NSLock()
|
|
private var timestampUnderlyingCallsCount = 0
|
|
open var timestampCallsCount: Int {
|
|
get { timestampCallsCountLock.withLock { timestampUnderlyingCallsCount } }
|
|
set { timestampCallsCountLock.withLock { timestampUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var timestampCalled: Bool {
|
|
return timestampCallsCount > 0
|
|
}
|
|
|
|
private let timestampReturnValueLock = NSLock()
|
|
open var timestampUnderlyingReturnValue: Timestamp!
|
|
open var timestampReturnValue: Timestamp! {
|
|
get { timestampReturnValueLock.withLock { timestampUnderlyingReturnValue } }
|
|
set { timestampReturnValueLock.withLock { timestampUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var timestampClosure: (() -> Timestamp)?
|
|
|
|
open override func timestamp() -> Timestamp {
|
|
timestampCallsCountLock.withLock { timestampUnderlyingCallsCount += 1 }
|
|
if let timestampClosure = timestampClosure {
|
|
return timestampClosure()
|
|
} else {
|
|
return timestampReturnValue
|
|
}
|
|
}
|
|
}
|
|
open class TimelineEventFilterSDKMock: MatrixRustSDK.TimelineEventFilter, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
static func reset()
|
|
{
|
|
}
|
|
}
|
|
open class TimelineItemSDKMock: MatrixRustSDK.TimelineItem, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
|
|
//MARK: - asEvent
|
|
|
|
private let asEventCallsCountLock = NSLock()
|
|
private var asEventUnderlyingCallsCount = 0
|
|
open var asEventCallsCount: Int {
|
|
get { asEventCallsCountLock.withLock { asEventUnderlyingCallsCount } }
|
|
set { asEventCallsCountLock.withLock { asEventUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var asEventCalled: Bool {
|
|
return asEventCallsCount > 0
|
|
}
|
|
|
|
private let asEventReturnValueLock = NSLock()
|
|
open var asEventUnderlyingReturnValue: EventTimelineItem?
|
|
open var asEventReturnValue: EventTimelineItem? {
|
|
get { asEventReturnValueLock.withLock { asEventUnderlyingReturnValue } }
|
|
set { asEventReturnValueLock.withLock { asEventUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var asEventClosure: (() -> EventTimelineItem?)?
|
|
|
|
open override func asEvent() -> EventTimelineItem? {
|
|
asEventCallsCountLock.withLock { asEventUnderlyingCallsCount += 1 }
|
|
if let asEventClosure = asEventClosure {
|
|
return asEventClosure()
|
|
} else {
|
|
return asEventReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - asVirtual
|
|
|
|
private let asVirtualCallsCountLock = NSLock()
|
|
private var asVirtualUnderlyingCallsCount = 0
|
|
open var asVirtualCallsCount: Int {
|
|
get { asVirtualCallsCountLock.withLock { asVirtualUnderlyingCallsCount } }
|
|
set { asVirtualCallsCountLock.withLock { asVirtualUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var asVirtualCalled: Bool {
|
|
return asVirtualCallsCount > 0
|
|
}
|
|
|
|
private let asVirtualReturnValueLock = NSLock()
|
|
open var asVirtualUnderlyingReturnValue: VirtualTimelineItem?
|
|
open var asVirtualReturnValue: VirtualTimelineItem? {
|
|
get { asVirtualReturnValueLock.withLock { asVirtualUnderlyingReturnValue } }
|
|
set { asVirtualReturnValueLock.withLock { asVirtualUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var asVirtualClosure: (() -> VirtualTimelineItem?)?
|
|
|
|
open override func asVirtual() -> VirtualTimelineItem? {
|
|
asVirtualCallsCountLock.withLock { asVirtualUnderlyingCallsCount += 1 }
|
|
if let asVirtualClosure = asVirtualClosure {
|
|
return asVirtualClosure()
|
|
} else {
|
|
return asVirtualReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - fmtDebug
|
|
|
|
private let fmtDebugCallsCountLock = NSLock()
|
|
private var fmtDebugUnderlyingCallsCount = 0
|
|
open var fmtDebugCallsCount: Int {
|
|
get { fmtDebugCallsCountLock.withLock { fmtDebugUnderlyingCallsCount } }
|
|
set { fmtDebugCallsCountLock.withLock { fmtDebugUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var fmtDebugCalled: Bool {
|
|
return fmtDebugCallsCount > 0
|
|
}
|
|
|
|
private let fmtDebugReturnValueLock = NSLock()
|
|
open var fmtDebugUnderlyingReturnValue: String!
|
|
open var fmtDebugReturnValue: String! {
|
|
get { fmtDebugReturnValueLock.withLock { fmtDebugUnderlyingReturnValue } }
|
|
set { fmtDebugReturnValueLock.withLock { fmtDebugUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var fmtDebugClosure: (() -> String)?
|
|
|
|
open override func fmtDebug() -> String {
|
|
fmtDebugCallsCountLock.withLock { fmtDebugUnderlyingCallsCount += 1 }
|
|
if let fmtDebugClosure = fmtDebugClosure {
|
|
return fmtDebugClosure()
|
|
} else {
|
|
return fmtDebugReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - uniqueId
|
|
|
|
private let uniqueIdCallsCountLock = NSLock()
|
|
private var uniqueIdUnderlyingCallsCount = 0
|
|
open var uniqueIdCallsCount: Int {
|
|
get { uniqueIdCallsCountLock.withLock { uniqueIdUnderlyingCallsCount } }
|
|
set { uniqueIdCallsCountLock.withLock { uniqueIdUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var uniqueIdCalled: Bool {
|
|
return uniqueIdCallsCount > 0
|
|
}
|
|
|
|
private let uniqueIdReturnValueLock = NSLock()
|
|
open var uniqueIdUnderlyingReturnValue: TimelineUniqueId!
|
|
open var uniqueIdReturnValue: TimelineUniqueId! {
|
|
get { uniqueIdReturnValueLock.withLock { uniqueIdUnderlyingReturnValue } }
|
|
set { uniqueIdReturnValueLock.withLock { uniqueIdUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var uniqueIdClosure: (() -> TimelineUniqueId)?
|
|
|
|
open override func uniqueId() -> TimelineUniqueId {
|
|
uniqueIdCallsCountLock.withLock { uniqueIdUnderlyingCallsCount += 1 }
|
|
if let uniqueIdClosure = uniqueIdClosure {
|
|
return uniqueIdClosure()
|
|
} else {
|
|
return uniqueIdReturnValue
|
|
}
|
|
}
|
|
}
|
|
open class UnreadNotificationsCountSDKMock: MatrixRustSDK.UnreadNotificationsCount, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
|
|
//MARK: - hasNotifications
|
|
|
|
private let hasNotificationsCallsCountLock = NSLock()
|
|
private var hasNotificationsUnderlyingCallsCount = 0
|
|
open var hasNotificationsCallsCount: Int {
|
|
get { hasNotificationsCallsCountLock.withLock { hasNotificationsUnderlyingCallsCount } }
|
|
set { hasNotificationsCallsCountLock.withLock { hasNotificationsUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var hasNotificationsCalled: Bool {
|
|
return hasNotificationsCallsCount > 0
|
|
}
|
|
|
|
private let hasNotificationsReturnValueLock = NSLock()
|
|
open var hasNotificationsUnderlyingReturnValue: Bool!
|
|
open var hasNotificationsReturnValue: Bool! {
|
|
get { hasNotificationsReturnValueLock.withLock { hasNotificationsUnderlyingReturnValue } }
|
|
set { hasNotificationsReturnValueLock.withLock { hasNotificationsUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var hasNotificationsClosure: (() -> Bool)?
|
|
|
|
open override func hasNotifications() -> Bool {
|
|
hasNotificationsCallsCountLock.withLock { hasNotificationsUnderlyingCallsCount += 1 }
|
|
if let hasNotificationsClosure = hasNotificationsClosure {
|
|
return hasNotificationsClosure()
|
|
} else {
|
|
return hasNotificationsReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - highlightCount
|
|
|
|
private let highlightCountCallsCountLock = NSLock()
|
|
private var highlightCountUnderlyingCallsCount = 0
|
|
open var highlightCountCallsCount: Int {
|
|
get { highlightCountCallsCountLock.withLock { highlightCountUnderlyingCallsCount } }
|
|
set { highlightCountCallsCountLock.withLock { highlightCountUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var highlightCountCalled: Bool {
|
|
return highlightCountCallsCount > 0
|
|
}
|
|
|
|
private let highlightCountReturnValueLock = NSLock()
|
|
open var highlightCountUnderlyingReturnValue: UInt32!
|
|
open var highlightCountReturnValue: UInt32! {
|
|
get { highlightCountReturnValueLock.withLock { highlightCountUnderlyingReturnValue } }
|
|
set { highlightCountReturnValueLock.withLock { highlightCountUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var highlightCountClosure: (() -> UInt32)?
|
|
|
|
open override func highlightCount() -> UInt32 {
|
|
highlightCountCallsCountLock.withLock { highlightCountUnderlyingCallsCount += 1 }
|
|
if let highlightCountClosure = highlightCountClosure {
|
|
return highlightCountClosure()
|
|
} else {
|
|
return highlightCountReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - notificationCount
|
|
|
|
private let notificationCountCallsCountLock = NSLock()
|
|
private var notificationCountUnderlyingCallsCount = 0
|
|
open var notificationCountCallsCount: Int {
|
|
get { notificationCountCallsCountLock.withLock { notificationCountUnderlyingCallsCount } }
|
|
set { notificationCountCallsCountLock.withLock { notificationCountUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var notificationCountCalled: Bool {
|
|
return notificationCountCallsCount > 0
|
|
}
|
|
|
|
private let notificationCountReturnValueLock = NSLock()
|
|
open var notificationCountUnderlyingReturnValue: UInt32!
|
|
open var notificationCountReturnValue: UInt32! {
|
|
get { notificationCountReturnValueLock.withLock { notificationCountUnderlyingReturnValue } }
|
|
set { notificationCountReturnValueLock.withLock { notificationCountUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var notificationCountClosure: (() -> UInt32)?
|
|
|
|
open override func notificationCount() -> UInt32 {
|
|
notificationCountCallsCountLock.withLock { notificationCountUnderlyingCallsCount += 1 }
|
|
if let notificationCountClosure = notificationCountClosure {
|
|
return notificationCountClosure()
|
|
} else {
|
|
return notificationCountReturnValue
|
|
}
|
|
}
|
|
}
|
|
open class UserIdentitySDKMock: MatrixRustSDK.UserIdentity, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
|
|
//MARK: - hasVerificationViolation
|
|
|
|
private let hasVerificationViolationCallsCountLock = NSLock()
|
|
private var hasVerificationViolationUnderlyingCallsCount = 0
|
|
open var hasVerificationViolationCallsCount: Int {
|
|
get { hasVerificationViolationCallsCountLock.withLock { hasVerificationViolationUnderlyingCallsCount } }
|
|
set { hasVerificationViolationCallsCountLock.withLock { hasVerificationViolationUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var hasVerificationViolationCalled: Bool {
|
|
return hasVerificationViolationCallsCount > 0
|
|
}
|
|
|
|
private let hasVerificationViolationReturnValueLock = NSLock()
|
|
open var hasVerificationViolationUnderlyingReturnValue: Bool!
|
|
open var hasVerificationViolationReturnValue: Bool! {
|
|
get { hasVerificationViolationReturnValueLock.withLock { hasVerificationViolationUnderlyingReturnValue } }
|
|
set { hasVerificationViolationReturnValueLock.withLock { hasVerificationViolationUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var hasVerificationViolationClosure: (() -> Bool)?
|
|
|
|
open override func hasVerificationViolation() -> Bool {
|
|
hasVerificationViolationCallsCountLock.withLock { hasVerificationViolationUnderlyingCallsCount += 1 }
|
|
if let hasVerificationViolationClosure = hasVerificationViolationClosure {
|
|
return hasVerificationViolationClosure()
|
|
} else {
|
|
return hasVerificationViolationReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - isVerified
|
|
|
|
private let isVerifiedCallsCountLock = NSLock()
|
|
private var isVerifiedUnderlyingCallsCount = 0
|
|
open var isVerifiedCallsCount: Int {
|
|
get { isVerifiedCallsCountLock.withLock { isVerifiedUnderlyingCallsCount } }
|
|
set { isVerifiedCallsCountLock.withLock { isVerifiedUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var isVerifiedCalled: Bool {
|
|
return isVerifiedCallsCount > 0
|
|
}
|
|
|
|
private let isVerifiedReturnValueLock = NSLock()
|
|
open var isVerifiedUnderlyingReturnValue: Bool!
|
|
open var isVerifiedReturnValue: Bool! {
|
|
get { isVerifiedReturnValueLock.withLock { isVerifiedUnderlyingReturnValue } }
|
|
set { isVerifiedReturnValueLock.withLock { isVerifiedUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var isVerifiedClosure: (() -> Bool)?
|
|
|
|
open override func isVerified() -> Bool {
|
|
isVerifiedCallsCountLock.withLock { isVerifiedUnderlyingCallsCount += 1 }
|
|
if let isVerifiedClosure = isVerifiedClosure {
|
|
return isVerifiedClosure()
|
|
} else {
|
|
return isVerifiedReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - masterKey
|
|
|
|
private let masterKeyCallsCountLock = NSLock()
|
|
private var masterKeyUnderlyingCallsCount = 0
|
|
open var masterKeyCallsCount: Int {
|
|
get { masterKeyCallsCountLock.withLock { masterKeyUnderlyingCallsCount } }
|
|
set { masterKeyCallsCountLock.withLock { masterKeyUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var masterKeyCalled: Bool {
|
|
return masterKeyCallsCount > 0
|
|
}
|
|
|
|
private let masterKeyReturnValueLock = NSLock()
|
|
open var masterKeyUnderlyingReturnValue: String?
|
|
open var masterKeyReturnValue: String? {
|
|
get { masterKeyReturnValueLock.withLock { masterKeyUnderlyingReturnValue } }
|
|
set { masterKeyReturnValueLock.withLock { masterKeyUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var masterKeyClosure: (() -> String?)?
|
|
|
|
open override func masterKey() -> String? {
|
|
masterKeyCallsCountLock.withLock { masterKeyUnderlyingCallsCount += 1 }
|
|
if let masterKeyClosure = masterKeyClosure {
|
|
return masterKeyClosure()
|
|
} else {
|
|
return masterKeyReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - pin
|
|
|
|
open var pinThrowableError: Error?
|
|
private let pinCallsCountLock = NSLock()
|
|
private var pinUnderlyingCallsCount = 0
|
|
open var pinCallsCount: Int {
|
|
get { pinCallsCountLock.withLock { pinUnderlyingCallsCount } }
|
|
set { pinCallsCountLock.withLock { pinUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var pinCalled: Bool {
|
|
return pinCallsCount > 0
|
|
}
|
|
open var pinClosure: (() async throws -> Void)?
|
|
|
|
open override func pin() async throws {
|
|
if let error = pinThrowableError {
|
|
throw error
|
|
}
|
|
pinCallsCountLock.withLock { pinUnderlyingCallsCount += 1 }
|
|
try await pinClosure?()
|
|
}
|
|
|
|
//MARK: - wasPreviouslyVerified
|
|
|
|
private let wasPreviouslyVerifiedCallsCountLock = NSLock()
|
|
private var wasPreviouslyVerifiedUnderlyingCallsCount = 0
|
|
open var wasPreviouslyVerifiedCallsCount: Int {
|
|
get { wasPreviouslyVerifiedCallsCountLock.withLock { wasPreviouslyVerifiedUnderlyingCallsCount } }
|
|
set { wasPreviouslyVerifiedCallsCountLock.withLock { wasPreviouslyVerifiedUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var wasPreviouslyVerifiedCalled: Bool {
|
|
return wasPreviouslyVerifiedCallsCount > 0
|
|
}
|
|
|
|
private let wasPreviouslyVerifiedReturnValueLock = NSLock()
|
|
open var wasPreviouslyVerifiedUnderlyingReturnValue: Bool!
|
|
open var wasPreviouslyVerifiedReturnValue: Bool! {
|
|
get { wasPreviouslyVerifiedReturnValueLock.withLock { wasPreviouslyVerifiedUnderlyingReturnValue } }
|
|
set { wasPreviouslyVerifiedReturnValueLock.withLock { wasPreviouslyVerifiedUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var wasPreviouslyVerifiedClosure: (() -> Bool)?
|
|
|
|
open override func wasPreviouslyVerified() -> Bool {
|
|
wasPreviouslyVerifiedCallsCountLock.withLock { wasPreviouslyVerifiedUnderlyingCallsCount += 1 }
|
|
if let wasPreviouslyVerifiedClosure = wasPreviouslyVerifiedClosure {
|
|
return wasPreviouslyVerifiedClosure()
|
|
} else {
|
|
return wasPreviouslyVerifiedReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - withdrawVerification
|
|
|
|
open var withdrawVerificationThrowableError: Error?
|
|
private let withdrawVerificationCallsCountLock = NSLock()
|
|
private var withdrawVerificationUnderlyingCallsCount = 0
|
|
open var withdrawVerificationCallsCount: Int {
|
|
get { withdrawVerificationCallsCountLock.withLock { withdrawVerificationUnderlyingCallsCount } }
|
|
set { withdrawVerificationCallsCountLock.withLock { withdrawVerificationUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var withdrawVerificationCalled: Bool {
|
|
return withdrawVerificationCallsCount > 0
|
|
}
|
|
open var withdrawVerificationClosure: (() async throws -> Void)?
|
|
|
|
open override func withdrawVerification() async throws {
|
|
if let error = withdrawVerificationThrowableError {
|
|
throw error
|
|
}
|
|
withdrawVerificationCallsCountLock.withLock { withdrawVerificationUnderlyingCallsCount += 1 }
|
|
try await withdrawVerificationClosure?()
|
|
}
|
|
}
|
|
open class WidgetDriverSDKMock: MatrixRustSDK.WidgetDriver, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
|
|
//MARK: - run
|
|
|
|
private let runRoomCapabilitiesProviderCallsCountLock = NSLock()
|
|
private var runRoomCapabilitiesProviderUnderlyingCallsCount = 0
|
|
open var runRoomCapabilitiesProviderCallsCount: Int {
|
|
get { runRoomCapabilitiesProviderCallsCountLock.withLock { runRoomCapabilitiesProviderUnderlyingCallsCount } }
|
|
set { runRoomCapabilitiesProviderCallsCountLock.withLock { runRoomCapabilitiesProviderUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var runRoomCapabilitiesProviderCalled: Bool {
|
|
return runRoomCapabilitiesProviderCallsCount > 0
|
|
}
|
|
private let runRoomCapabilitiesProviderReceivedArgumentsLock = NSLock()
|
|
private var runRoomCapabilitiesProviderUnderlyingReceivedArguments: (room: Room, capabilitiesProvider: WidgetCapabilitiesProvider)?
|
|
open var runRoomCapabilitiesProviderReceivedArguments: (room: Room, capabilitiesProvider: WidgetCapabilitiesProvider)? {
|
|
get { runRoomCapabilitiesProviderReceivedArgumentsLock.withLock { runRoomCapabilitiesProviderUnderlyingReceivedArguments } }
|
|
set { runRoomCapabilitiesProviderReceivedArgumentsLock.withLock { runRoomCapabilitiesProviderUnderlyingReceivedArguments = newValue } }
|
|
}
|
|
private let runRoomCapabilitiesProviderReceivedInvocationsLock = NSLock()
|
|
private var runRoomCapabilitiesProviderUnderlyingReceivedInvocations: [(room: Room, capabilitiesProvider: WidgetCapabilitiesProvider)] = []
|
|
open var runRoomCapabilitiesProviderReceivedInvocations: [(room: Room, capabilitiesProvider: WidgetCapabilitiesProvider)] {
|
|
get { runRoomCapabilitiesProviderReceivedInvocationsLock.withLock { runRoomCapabilitiesProviderUnderlyingReceivedInvocations } }
|
|
set { runRoomCapabilitiesProviderReceivedInvocationsLock.withLock { runRoomCapabilitiesProviderUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
open var runRoomCapabilitiesProviderClosure: ((Room, WidgetCapabilitiesProvider) async -> Void)?
|
|
|
|
open override func run(room: Room, capabilitiesProvider: WidgetCapabilitiesProvider) async {
|
|
runRoomCapabilitiesProviderCallsCountLock.withLock { runRoomCapabilitiesProviderUnderlyingCallsCount += 1 }
|
|
runRoomCapabilitiesProviderReceivedArguments = (room: room, capabilitiesProvider: capabilitiesProvider)
|
|
runRoomCapabilitiesProviderReceivedInvocationsLock.withLock { runRoomCapabilitiesProviderUnderlyingReceivedInvocations.append((room: room, capabilitiesProvider: capabilitiesProvider)) }
|
|
await runRoomCapabilitiesProviderClosure?(room, capabilitiesProvider)
|
|
}
|
|
}
|
|
open class WidgetDriverHandleSDKMock: MatrixRustSDK.WidgetDriverHandle, @unchecked Sendable {
|
|
public init() {
|
|
super.init(noHandle: .init())
|
|
}
|
|
|
|
public required init(unsafeFromHandle handle: UInt64) {
|
|
fatalError("init(unsafeFromHandle:) has not been implemented")
|
|
}
|
|
|
|
fileprivate var handle: UInt64 {
|
|
get { return underlyingHandle }
|
|
set(value) { underlyingHandle = value }
|
|
}
|
|
fileprivate var underlyingHandle: UInt64!
|
|
|
|
//MARK: - recv
|
|
|
|
private let recvCallsCountLock = NSLock()
|
|
private var recvUnderlyingCallsCount = 0
|
|
open var recvCallsCount: Int {
|
|
get { recvCallsCountLock.withLock { recvUnderlyingCallsCount } }
|
|
set { recvCallsCountLock.withLock { recvUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var recvCalled: Bool {
|
|
return recvCallsCount > 0
|
|
}
|
|
|
|
private let recvReturnValueLock = NSLock()
|
|
open var recvUnderlyingReturnValue: String?
|
|
open var recvReturnValue: String? {
|
|
get { recvReturnValueLock.withLock { recvUnderlyingReturnValue } }
|
|
set { recvReturnValueLock.withLock { recvUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var recvClosure: (() async -> String?)?
|
|
|
|
open override func recv() async -> String? {
|
|
recvCallsCountLock.withLock { recvUnderlyingCallsCount += 1 }
|
|
if let recvClosure = recvClosure {
|
|
return await recvClosure()
|
|
} else {
|
|
return recvReturnValue
|
|
}
|
|
}
|
|
|
|
//MARK: - send
|
|
|
|
private let sendMsgCallsCountLock = NSLock()
|
|
private var sendMsgUnderlyingCallsCount = 0
|
|
open var sendMsgCallsCount: Int {
|
|
get { sendMsgCallsCountLock.withLock { sendMsgUnderlyingCallsCount } }
|
|
set { sendMsgCallsCountLock.withLock { sendMsgUnderlyingCallsCount = newValue } }
|
|
}
|
|
open var sendMsgCalled: Bool {
|
|
return sendMsgCallsCount > 0
|
|
}
|
|
private let sendMsgReceivedMsgLock = NSLock()
|
|
private var sendMsgUnderlyingReceivedMsg: String?
|
|
open var sendMsgReceivedMsg: String? {
|
|
get { sendMsgReceivedMsgLock.withLock { sendMsgUnderlyingReceivedMsg } }
|
|
set { sendMsgReceivedMsgLock.withLock { sendMsgUnderlyingReceivedMsg = newValue } }
|
|
}
|
|
private let sendMsgReceivedInvocationsLock = NSLock()
|
|
private var sendMsgUnderlyingReceivedInvocations: [String] = []
|
|
open var sendMsgReceivedInvocations: [String] {
|
|
get { sendMsgReceivedInvocationsLock.withLock { sendMsgUnderlyingReceivedInvocations } }
|
|
set { sendMsgReceivedInvocationsLock.withLock { sendMsgUnderlyingReceivedInvocations = newValue } }
|
|
}
|
|
|
|
private let sendMsgReturnValueLock = NSLock()
|
|
open var sendMsgUnderlyingReturnValue: Bool!
|
|
open var sendMsgReturnValue: Bool! {
|
|
get { sendMsgReturnValueLock.withLock { sendMsgUnderlyingReturnValue } }
|
|
set { sendMsgReturnValueLock.withLock { sendMsgUnderlyingReturnValue = newValue } }
|
|
}
|
|
open var sendMsgClosure: ((String) async -> Bool)?
|
|
|
|
open override func send(msg: String) async -> Bool {
|
|
sendMsgCallsCountLock.withLock { sendMsgUnderlyingCallsCount += 1 }
|
|
sendMsgReceivedMsg = msg
|
|
sendMsgReceivedInvocationsLock.withLock { sendMsgUnderlyingReceivedInvocations.append(msg) }
|
|
if let sendMsgClosure = sendMsgClosure {
|
|
return await sendMsgClosure(msg)
|
|
} else {
|
|
return sendMsgReturnValue
|
|
}
|
|
}
|
|
}
|
|
// swiftlint:enable all
|