Class RecordHandler RecordHandler

The factory method's for deepstreamHub's realtime datastore concepts, such as getRecord(recordName), getList(_:), provider functionality such as listen(_:listener:) and single requests like snapshot(_:)

Methods

cass func getRecord(_ recordName: String) -> Self

Returns an existing record or creates a new one. If creating a new one the record will not be in a ready state till it is loaded from the server.

Show example...

let record = client.record.getRecord("users/A")

class func getList(_ listName: String) -> List

Returns an existing List or creates a new one. A list is a specialised type of record that holds an array of recordNames.

Show example...

let list = client.record.getList("users")

class func getAnonymousRecord() -> AnonymousRecord

Returns an AnonymousRecord. An anonymous record is effectively a wrapper that mimicks the API of a record, but allows for the underlying record to be swapped without losing subscriptions etc.

This is particularly useful when selecting from a number of similarly structured records. E.g. a list of users that can be choosen from a list.

The only API differences to a normal record is an additional setName(_:) method.

class func snapshot(_ recordName: String) -> SnapshotResult

Retrieves a SnapshotResult with the current record data. Using this doesn't subscribe the client to changes the way getRecord(name) does.

Show example...

let result = client.record.snapshot("user/B")

class func has(_ recordName: String) throws -> Bool

Returns a HasResult that shows whether or not the record exists.

Show example...

let result = client.record.has("user/C")

class func listen(_ pattern: String, listenCallback: ListenListener) -> Void

Allows to listen for record subscriptions made by this or other clients. This is useful to create "active" data providers, e.g. providers that only provide data for a particular record if a user is actually interested in it.

You can only listen to a pattern once, and if multiple listeners match the same pattern only a single one will be notified.

Show example...

final class UsersListenListener: NSObject, ListenListener {
    func onSubscription(forPatternAdded subscription: String!) -> jboolean {
      if (canProvide) {
        return true
      } else {
        return false
      }
    }
    func onSubscription(forPatternRemoved subscription: String!) {
        // handle unsubscription
    }
}
client.event.listen("users/*", UsersListenListener())

void unlisten(_ pattern: String)

Remove the listener added via listen(_:listener:). This will remove the provider as the active provider and allow another provider to take its place.

Show example...

client.record.unlisten("users/*", listener: listener);