Classes

The following classes are available globally.

  • A 128-bit IEEE 754-2008 decimal floating point number.

    This type is similar to Swift’s built-in Decimal type, but allocates bits differently, resulting in a different representable range. (NS)Decimal stores a significand of up to 38 digits long and an exponent from -128 to 127, while this type stores up to 34 digits of significand and an exponent from -6143 to 6144.

    See more

    Declaration

    Swift

    @objc(RealmSwiftDecimal128)
    public final class Decimal128 : RLMDecimal128, Decodable
    extension Decimal128: BSON
    extension Decimal128: Encodable
    extension Decimal128: ExpressibleByIntegerLiteral
    extension Decimal128: ExpressibleByFloatLiteral
    extension Decimal128: ExpressibleByStringLiteral
    extension Decimal128: Comparable
    extension Decimal128: Numeric
    extension Decimal128: _QueryNumeric
    extension Decimal128: _RealmCollectionValueInsideOptional
    extension Decimal128: MinMaxType
    extension Decimal128: AddableType
    extension Decimal128: SortableType
  • A 12-byte (probably) unique object identifier.

    ObjectIds are similar to a GUID or a UUID, and can be used to uniquely identify objects without a centralized ID generator. An ObjectID consists of:

    1. A 4 byte timestamp measuring the creation time of the ObjectId in seconds since the Unix epoch.
    2. A 5 byte random value
    3. A 3 byte counter, initialized to a random value.

    ObjectIds are intended to be fast to generate. Sorting by an ObjectId field will typically result in the objects being sorted in creation order.

    See more

    Declaration

    Swift

    @objc(RealmSwiftObjectId)
    public final class ObjectId : RLMObjectId, Decodable
    extension ObjectId: BSON
    extension ObjectId: Encodable
    extension ObjectId: Comparable
    extension ObjectId: _RealmCollectionValueInsideOptional
  • List is the container type in Realm used to define to-many relationships.

    Like Swift’s Array, List is a generic type that is parameterized on the type it stores. This can be either an Object subclass or one of the following types: Bool, Int, Int8, Int16, Int32, Int64, Float, Double, String, Data, Date, Decimal128, and ObjectId (and their optional versions)

    Unlike Swift’s native collections, Lists are reference types, and are only immutable if the Realm that manages them is opened as read-only.

    Lists can be filtered and sorted with the same predicates as Results<Element>.

    Properties of List type defined on Object subclasses must be declared as let and cannot be dynamic.

    See more

    Declaration

    Swift

    public final class List<Element> : RLMSwiftCollectionBase, RealmCollectionImpl where Element : RealmCollectionValue
    extension List: ObservableObject, RealmSubscribable
    extension List: MutableCollection
    extension List: Decodable where Element: Decodable
    extension List: Encodable where Element: Encodable
  • MutableSet is the container type in Realm used to define to-many relationships with distinct values as objects.

    Like Swift’s Set, MutableSet is a generic type that is parameterized on the type it stores. This can be either an Object subclass or one of the following types: Bool, Int, Int8, Int16, Int32, Int64, Float, Double, String, Data, Date, Decimal128, and ObjectId (and their optional versions)

    Unlike Swift’s native collections, MutableSets are reference types, and are only immutable if the Realm that manages them is opened as read-only.

    MutableSet’s can be filtered and sorted with the same predicates as Results<Element>.

    Properties of MutableSet type defined on Object subclasses must be declared as let and cannot be dynamic.

    See more

    Declaration

    Swift

    public final class MutableSet<Element> : RLMSwiftCollectionBase, RealmCollectionImpl where Element : RealmCollectionValue
    extension MutableSet: ObservableObject, RealmSubscribable
    extension MutableSet: Decodable where Element: Decodable
    extension MutableSet: Encodable where Element: Encodable
  • Map

    Map is a key-value storage container used to store supported Realm types.

    Map is a generic type that is parameterized on the type it stores. This can be either an Object subclass or one of the following types: Bool, Int, Int8, Int16, Int32, Int64, Float, Double, String, Data, Date, Decimal128, and ObjectId (and their optional versions)

    Note

    Optional versions of the above types except Object are only supported in non-synchronized Realms.

    Map only supports String as a key.

    Unlike Swift’s native collections, Maps is a reference types, and are only immutable if the Realm that manages them is opened as read-only.

    A Map can be filtered and sorted with the same predicates as Results<Value>.

    Properties of Map type defined on Object subclasses must be declared as let and cannot be dynamic.

    See more

    Declaration

    Swift

    public final class Map<Key, Value> : RLMSwiftCollectionBase where Key : _MapKey, Value : RealmCollectionValue
    extension Map: ObservableObject, RealmSubscribable
    extension Map: Sequence
    extension Map: RealmKeyedCollection
    extension Map: Decodable where Key: Decodable, Value: Decodable
    extension Map: Encodable where Key: Encodable, Value: Encodable
  • A RealmOptional instance represents an optional value for types that can’t be directly declared as @objc in Swift, such as Int, Float, Double, and Bool.

    To change the underlying value stored by a RealmOptional instance, mutate the instance’s value property.

    See more

    Declaration

    Swift

    @available(*, deprecated, renamed: "RealmProperty", message: "RealmOptional<T> has been deprecated, use RealmProperty<T?> instead.")
    public final class RealmOptional<Value> : RLMSwiftValueStorage where Value : RealmOptionalType
    extension RealmOptional: Equatable where Value: Equatable
    extension RealmOptional: Codable where Value: Codable, Value: _RealmSchemaDiscoverable

ProjectionOservable

  • Projection is a light weight model of the original Realm Object or EmbeddedObject. You can use Projection as a view model to minimize boilerplate.

    Example of usage:

    public class Person: Object {
        @Persisted var firstName = ""
        @Persisted var lastName = ""
        @Persisted var address: Address? = nil
        @Persisted var friends = List<Person>()
        @Persisted var reviews = List<String>()
    }
    
    public class Address: EmbeddedObject {
        @Persisted var city: String = ""
        @Persisted var country = ""
    }
    
    class PersonProjection: Projection<Person> {
        @Projected(\Person.firstName) var firstName
        @Projected(\Person.lastName.localizedUppercase) var lastNameCaps
        @Projected(\Person.address.city) var homeCity
        @Projected(\Person.friends.projectTo.firstName) var friendsFirstName: ProjectedCollection<String>
    }
    

    ### Supported property types Projection can transform the original @Persisted properties in several ways:

    • Passthrough - Projection‘s property will have same name and type as original object. See PersonProjection.firstName.
    • Rename - Projection’s property will have same type as original object just with the new name.
    • Keypath resolution - you can access the certain properties of the projected Object. See PersonProjection.lastNameCaps and PersonProjection.homeCity.
    • Collection mapping - List and MutableSetof Objects or EmbeddedObjects can be projected as a collection of primitive values. See PersonProjection.friendsFirstName.
    • Exclusion - all properties of the original Realm object that were not defined in the projection model will be excluded from projection. Any changes happened on those properties will not trigger a change notification for the Projection. You still can access the original Object or EmbeddedObject and observe notifications directly on it.

    Note

    each @Persisted property can be @Projected in different ways in the same Projection class. Each Object or EmbeddedObject can have sevaral projections of same or different classes at once.

    Querying

    You can retrieve all Projections of a given type from a Realm by calling the objects(_:) of Realm or init(projecting:) of Projection’s class:

    let projections = realm.object(PersonProjection.self)
    let personObject = realm.create(Person.self)
    let singleProjection = PersonProjection(projecting: personObject)
    
    See more

    Declaration

    Swift

    open class Projection<Root> : RealmCollectionValue, ProjectionObservable where Root : RLMObjectBase, Root : RealmCollectionValue
    extension Projection: KeypathSortable
    extension Projection: ThreadConfined where Root: ThreadConfined
    extension Projection: ObservableObject, RealmSubscribable where Root: ThreadConfined
  • A RealmProperty instance represents an polymorphic value for supported types.

    To change the underlying value stored by a RealmProperty instance, mutate the instance’s value property.

    Note

    An RealmProperty should not be declared as @objc dynamic on a Realm Object. Use let instead.
    See more

    Declaration

    Swift

    public final class RealmProperty<Value> : RLMSwiftValueStorage where Value : RealmPropertyType
    extension RealmProperty: Equatable where Value: Equatable
    extension RealmProperty: Codable where Value: Codable

ThreadSafe propertyWrapper

  • A property wrapper type that may be passed between threads.

    A @ThreadSafe property contains a thread-safe reference to the underlying wrapped value. This reference is resolved to the thread on which the wrapped value is accessed. A new thread safe reference is created each time the property is accessed.

    Warning

    This property wrapper should not be used for properties on long lived objects. @ThreadSafe properties contain a ThreadSafeReference which can pin the source version of the Realm in use. This means that this property wrapper is better suited for function arguments and local variables that get captured by an aynchronously dispatched block.

    Declaration

    Swift

    @propertyWrapper
    public final class ThreadSafe<T> where T : ThreadConfined
    extension ThreadSafe: @unchecked Sendable