Object

A publisher that emits Void each time the object changes.

Despite the name, this actually emits after the object has changed.

Undocumented

Undocumented

Undocumented

Undocumented

Undocumented

Undocumented

Creates an unmanaged instance of a Realm object.

The value argument is used to populate the object. It can be a key-value coding compliant object, an array or dictionary returned from the methods in NSJSONSerialization, or an Array containing one element for each managed property. An exception will be thrown if any required properties are not present and those properties were not defined with default values.

When passing in an Array as the value argument, all properties must be present, valid and in the same order as the properties defined in the model.

Call add(_:) on a Realm instance to add an unmanaged object into that Realm.

The Realm which manages the object, or nil if the object is unmanaged.

The object schema which lists the managed properties for the object.

Indicates if the object can no longer be accessed because it is now invalid.

An object can no longer be accessed if the object has been deleted from the Realm that manages it, or if invalidate() is called on that Realm. This property is key-value observable.

A human-readable description of the object.

Override this method to specify the name of a property to be used as the primary key.

Only properties of types String, Int, ObjectId and UUID can be designated as the primary key. Primary key properties enforce uniqueness for each value whenever the property is set, which incurs minor overhead. Indexes are created automatically for primary key properties.

Override this method to specify the names of properties to ignore. These properties will not be managed by the Realm that manages the object.

Returns an array of property names for properties which should be indexed.

Only string, integer, boolean, Date, and NSDate properties are supported.

Override this method to specify a map of public-private property names. This will set a different persisted property name on the Realm, and allows using the public name for any operation with the property. (Ex: Queries, Sorting, …). This very helpful if you need to map property names from your Device Sync JSON schema to local property names.

class Person: Object {
    @Persisted var firstName: String
    @Persisted var birthDate: Date
    @Persisted var age: Int

    override class public func propertiesMapping() -> [String : String] {
        ["firstName": "first_name",
         "birthDate": "birth_date"]
    }
}

let migrationBlock = { migration, oldSchemaVersion in
    migration.enumerateObjects(ofType: "Person", { oldObj, newObj in
       let oldPropertyValue = oldObj!["first_name"] as! String
       // Use this value in migration
    })
}

This has to be done as well when renaming a property.

let migrationBlock = { migration, oldSchemaVersion in
    migration.renameProperty(onType: "Person", from: "first_name", to: "complete_name")
}

Returns or sets the value of the property with the given name.

Registers a block to be called each time the object changes.

The block will be asynchronously called after each write transaction which deletes the object or modifies any of the managed properties of the object, including self-assignments that set a property to its existing value.

For write transactions performed on different threads or in different processes, the block will be called when the managing Realm is (auto)refreshed to a version including the changes, while for local write transactions it will be called at some point in the future after the write transaction is committed.

If no key paths are given, the block will be executed on any insertion, modification, or deletion for all object properties and the properties of any nested, linked objects. If a key path or key paths are provided, then the block will be called for changes which occur only on the provided key paths. For example, if:

class Dog: Object {
    @Persisted var name: String
    @Persisted var adopted: Bool
    @Persisted var siblings: List<Dog>
}

// ... where `dog` is a managed Dog object.
dog.observe(keyPaths: ["adopted"], { changes in
   // ...
})

• The above notification block fires for changes to the adopted property, but not for any changes made to name.
• If the observed key path were ["siblings"], then any insertion, deletion, or modification to the siblings list will trigger the block. A change to someSibling.name would not trigger the block (where someSibling is an element contained in siblings)

• If the observed key path were ["siblings.name"], then any insertion or deletion to the siblings list would trigger the block. For objects contained in the siblings list, only modifications to their name property will trigger the block.

If no queue is given, notifications are delivered via the standard run loop, and so can’t be delivered while the run loop is blocked by other activity. If a queue is given, notifications are delivered to that queue instead. When notifications can’t be delivered instantly, multiple notifications may be coalesced into a single notification.

Unlike with List and Results, there is no “initial” callback made after you add a new notification block.

Only objects which are managed by a Realm can be observed in this way. You must retain the returned token for as long as you want updates to be sent to the block. To stop receiving updates, call invalidate() on the token.

It is safe to capture a strong reference to the observed object within the callback block. There is no retain cycle due to that the callback is retained by the returned token and not by the object itself.

Registers a block to be called each time the object changes.

The block will be asynchronously called after each write transaction which deletes the object or modifies any of the managed properties of the object, including self-assignments that set a property to its existing value.

For write transactions performed on different threads or in different processes, the block will be called when the managing Realm is (auto)refreshed to a version including the changes, while for local write transactions it will be called at some point in the future after the write transaction is committed.

If no key paths are given, the block will be executed on any insertion, modification, or deletion for all object properties and the properties of any nested, linked objects. If a key path or key paths are provided, then the block will be called for changes which occur only on the provided key paths. For example, if:

class Dog: Object {
    @Persisted var name: String
    @Persisted var adopted: Bool
    @Persisted var siblings: List<Dog>
}

// ... where `dog` is a managed Dog object.
dog.observe(keyPaths: [\Dog.adopted], { changes in
   // ...
})

• The above notification block fires for changes to the adopted property, but not for any changes made to name.
• If the observed key path were [\Dog.siblings], then any insertion, deletion, or modification to the siblings list will trigger the block. A change to someSibling.name would not trigger the block (where someSibling is an element contained in siblings)

• If the observed key path were [\Dog.siblings.name], then any insertion or deletion to the siblings list would trigger the block. For objects contained in the siblings list, only modifications to their name property will trigger the block.

If no queue is given, notifications are delivered via the standard run loop, and so can’t be delivered while the run loop is blocked by other activity. If a queue is given, notifications are delivered to that queue instead. When notifications can’t be delivered instantly, multiple notifications may be coalesced into a single notification.

Unlike with List and Results, there is no “initial” callback made after you add a new notification block.

Only objects which are managed by a Realm can be observed in this way. You must retain the returned token for as long as you want updates to be sent to the block. To stop receiving updates, call invalidate() on the token.

It is safe to capture a strong reference to the observed object within the callback block. There is no retain cycle due to that the callback is retained by the returned token and not by the object itself.

Returns whether two Realm objects are the same.

Objects are considered the same if and only if they are both managed by the same Realm and point to the same underlying object in the database.

Indicates if this object is frozen.

Returns a frozen (immutable) snapshot of this object.

The frozen copy is an immutable object which contains the same data as this object currently contains, but will not update when writes are made to the containing Realm. Unlike live objects, frozen objects can be accessed from any thread.

Returns a live (mutable) reference of this object.

This method creates a managed accessor to a live copy of the same frozen object. Will return self if called on an already live object.