Protocols

A protocol defining iterator support for RLMArray, RLMSet & RLMResults.

A protocol defining iterator support for RLMDictionary

Protocol representing a BSON value.

A protocol which defines a default identity for Realm Objects

Declaring your Object subclass as conforming to this protocol will supply a default implementation for Identifiable‘s id which works for Realm Objects:

// Automatically conforms to `Identifiable`
class MyObjectType: Object, ObjectKeyIdentifiable {
    // ...
}

You can also manually conform to Identifiable if you wish, but note that using the object’s memory address does not work for managed objects.

A type which can be passed to valuePublisher() or changesetPublisher().

A homogenous collection of Objects which can be retrieved, filtered, sorted, and operated upon.

A homogenous key-value collection of Objects which can be retrieved, filtered, sorted, and operated upon.

Delegate which is used for subscribing to changes on a MongoCollection.watch() stream.

An enum type which can be stored on a Realm Object.

Only @objc enums backed by an Int can be stored on a Realm object, and the enum type must explicitly conform to this protocol. For example:

@objc enum MyEnum: Int, RealmEnum {
   case first = 1
   case second = 2
   case third = 7
}

class MyModel: Object {
   @objc dynamic enumProperty = MyEnum.first
   let optionalEnumProperty = RealmOptional<MyEnum>()
}

A protocol describing types that can parameterize a RealmOptional.

A type which can be stored in a Realm List, MutableSet, or Results.

Declaring additional types as conforming to this protocol will not make them actually work. Most of the logic for how to store values in Realm is not implemented in Swift and there is currently no extension mechanism for supporting more types.

A protocol describing types that can parameterize a RealmPropertyType.

Types of properties which can be used with the minimum and maximum value APIs.

Types of properties which can be used with the sum and average value APIs.

Objects of types which conform to ThreadConfined can be managed by a Realm, which will make them bound to a thread-specific Realm instance. Managed objects must be explicitly exported and imported to be passed between threads.

Managed instances of objects conforming to this protocol can be converted to a thread-safe reference for transport between threads by passing to the ThreadSafeReference(to:) constructor.

Note that only types defined by Realm can meaningfully conform to this protocol, and defining new classes which attempt to conform to it will not make them work with ThreadSafeReference.