RLMDictionary

The number of entries in the dictionary.

The type of the objects in the dictionary.

The type of the key used in this dictionary.

Indicates whether the objects in the collection can be nil.

The class name of the objects contained in the dictionary.

Will be nil if type is not RLMPropertyTypeObject.

The Realm which manages the dictionary. Returns nil for unmanaged dictionary.

Indicates if the dictionary can no longer be accessed.

Indicates if the dictionary is frozen.

Frozen dictionaries are immutable and can be accessed from any thread. Frozen dictionaries are created by calling -freeze on a managed live dictionary. Unmanaged dictionaries are never frozen.

Returns the value associated with a given key.

@discussion If key does not start with “@”, invokes object(forKey:). If key does start with “@”, strips the “@” and invokes [super valueForKey:] with the rest of the key.

Returns an array containing the dictionary’s keys.

Returns an array containing the dictionary’s values.

Returns the value associated with a given key.

Returns the value associated with a given key.

Applies a given block object to the each key-value pair of the dictionary.

Replace the contents of a dictionary with the contents of another dictionary - NSDictionary or RLMDictionary.

This will remove all elements in this dictionary and then apply each element from the given dictionary.

Removes all contents in the dictionary.

Removes from the dictionary entries specified by elements in a given array. If a given key does not exist, no mutation will happen for that key.

Removes a given key and its associated value from the dictionary. If the key does not exist the dictionary will not be modified.

Adds a given key-value pair to the dictionary if the key is not present, or updates the value for the given key if the key already present.

Adds a given key-value pair to the dictionary if the key is not present, or updates the value for the given key if the key already present.

Adds to the receiving dictionary the entries from another dictionary.

Returns all the values matching the given predicate in the dictionary.

Returns all the values matching the given predicate in the dictionary.

Returns a sorted RLMResults of all values in the dictionary.

Returns a sorted RLMResults of all values in the dictionary.

Returns a distinct RLMResults from all values in the dictionary.

Returns the minimum (lowest) value of the given property among all the values in the dictionary.

NSNumber *min = [object.dictionaryProperty minOfProperty:@"age"];

Returns the maximum (highest) value of the given property among all the objects in the dictionary.

NSNumber *max = [object.dictionaryProperty maxOfProperty:@"age"];

Returns the sum of distinct values of a given property over all the objects in the dictionary.

NSNumber *sum = [object.dictionaryProperty sumOfProperty:@"age"];

Returns the average value of a given property over the objects in the dictionary.

NSNumber *average = [object.dictionaryProperty averageOfProperty:@"age"];

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

The block will be asynchronously called with the initial dictionary, and then called again after each write transaction which changes any of the keys or values within the dictionary.

The changes parameter will be nil the first time the block is called. For each call after that, it will contain information about which keys in the dictionary were added, modified or deleted. If a write transaction did not modify any keys or values in the dictionary, the block is not called at all.

The error parameter is present only for backwards compatibility and will always be nil.

Notifications are delivered via the standard run loop, and so can’t be delivered while the run loop is blocked by other activity. When notifications can’t be delivered instantly, multiple notifications may be coalesced into a single notification. This can include the notification with the initial results. For example, the following code performs a write transaction immediately after adding the notification block, so there is no opportunity for the initial notification to be delivered first. As a result, the initial notification will reflect the state of the Realm after the write transaction.

Person *person = [[Person allObjectsInRealm:realm] firstObject];
NSLog(@"person.dogs.count: %zu", person.dogs.count); // => 0
self.token = [person.dogs addNotificationBlock(RLMDictionary<NSString *, Dog *><RLMString, Dog> *dogs,
                                  RLMDictionaryChange *changes,
                                  NSError *error) {
    // Only fired once for the example
    NSLog(@"dogs.count: %zu", dogs.count); // => 1
}];
[realm transactionWithBlock:^{
    Dog *dog = [[Dog alloc] init];
    dog.name = @"Rex";
    person.dogs[@"frenchBulldog"] = dog;
}];
// end of run loop execution context

You must retain the returned token for as long as you want updates to continue to be sent to the block. To stop receiving updates, call -invalidate on the token.

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

The block will be asynchronously called with the initial dictionary, and then called again after each write transaction which changes any of the key-value in the dictionary or which objects are in the results.

The changes parameter will be nil the first time the block is called. For each call after that, it will contain information about which keys in the dictionary were added or modified. If a write transaction did not modify any objects in the dictionary, the block is not called at all.

The error parameter is present only for backwards compatibility and will always be nil.

Notifications are delivered on the given queue. If the queue is blocked and notifications can’t be delivered instantly, multiple notifications may be coalesced into a single notification.

You must retain the returned token for as long as you want updates to continue to be sent to the block. To stop receiving updates, call -invalidate on the token.

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

The block will be asynchronously called with the initial dictionary, and then called again after each write transaction which changes any of the key-value in the dictionary or which objects are in the results.

The changes parameter will be nil the first time the block is called. For each call after that, it will contain information about which keys in the dictionary were added or modified. If a write transaction did not modify any objects in the dictionary, the block is not called at all.

The error parameter is present only for backwards compatibility and will always be nil.

Notifications are delivered on the given queue. If the queue is blocked and notifications can’t be delivered instantly, multiple notifications may be coalesced into a single notification.

You must retain the returned token for as long as you want updates to continue to be sent to the block. To stop receiving updates, call -invalidate on the token.

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

The block will be asynchronously called with the initial dictionary, and then called again after each write transaction which changes any of the key-value in the dictionary or which objects are in the results.

The changes parameter will be nil the first time the block is called. For each call after that, it will contain information about which keys in the dictionary were added or modified. If a write transaction did not modify any objects in the dictionary, the block is not called at all.

The error parameter is present only for backwards compatibility and will always be nil.

You must retain the returned token for as long as you want updates to continue to be sent to the block. To stop receiving updates, call -invalidate on the token.

Returns a frozen (immutable) snapshot of a dictionary.

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

Returns a live version of this frozen collection.

This method resolves a reference to a live copy of the same frozen collection. If called on a live collection, will return itself.

-[RLMDictionary init] is not available because RLMDictionarys cannot be created directly. RLMDictionary properties on RLMObjects are lazily created when accessed.

+[RLMDictionary new] is not available because RLMDictionarys cannot be created directly. RLMDictionary properties on RLMObjects are lazily created when accessed.