     public func cancelWrite() {
         rlmRealm.cancelWriteTransaction()
     }
+
+    // MARK: Adding and Deleting objects
+
+    /**
+    Adds an object to be persisted it in this Realm.
+
+    Once added, this object can be retrieved using the `objects(_:)` free function.
+    When added, all linked (child) objects referenced by this object will also be
+    added to the Realm if they are not already in it. If the object or any linked
+    objects already belong to a different Realm an exception will be thrown. Use
+    `Object(realm:object:)` to insert a copy of a persisted object
+    into a different Realm.
+
+    The object to be added must be valid and cannot have been previously deleted
+    from a Realm (i.e. `invalidated`) must be false.
+
+    :param: object Object to be added to this Realm.
+    */
+    public func add(object: Object) {
+        RLMAddObjectToRealm(object, rlmRealm, .allZeros)
+    }
+
+    /**
+    Adds objects in the given sequence to be persisted it in this Realm.
+
+    :see: add(object:)
+
+    :param: objects A sequence which contains objects to be added to this Realm.
+    */
+    public func add<S: SequenceType where S.Generator.Element: Object>(objects: S) {
+        for obj in objects {
+            add(obj)
+        }
+    }
+
+    /**
+    Adds or updates an object to be persisted it in this Realm. The object provided must have a designated
+    primary key. If no objects exist in the Realm instance with the same primary key value, the object is
+    inserted. Otherwise, the existing object is updated with any changed values.
+
+    As with `add`, the object cannot already be persisted in a different
+    Realm. Use `createOrUpdate` to copy values to a different Realm.
+
+    :param: object Object to be added or updated.
+    */
+    public func addOrUpdate(object: Object) {
+        if object.objectSchema.primaryKeyProperty == nil {
+            fatalError("'\(object.objectSchema.className)' does not have a primary key and can not be updated")
+        }
+
+        RLMAddObjectToRealm(object, rlmRealm, RLMCreationOptions.UpdateOrCreate)
+    }
+
+    /**
+    Adds or updates objects in the given array to be persisted it in this Realm.
+
+    :see: addOrUpdate(object:)
+
+    :param: objects A sequence of `Object`s to be added to this Realm.
+    */
+    public func addOrUpdate<S: SequenceType where S.Generator.Element: Object>(objects: S) {
+        for obj in objects {
+            addOrUpdate(obj)
+        }
+    }
+
+    /**
+    Deletes the given object from this Realm.
+
+    :param: object The object to be deleted.
+    */
+    public func delete(object: Object) {
+        RLMDeleteObjectFromRealm(object)
+    }
+
+    /**
+    Deletes the given objects from this Realm.
+
+    :param: object The objects to be deleted.
+    */
+    public func delete(objects: List<Object>) {
+        rlmRealm.deleteObjects(objects)
+    }
+
+    /**
+    Deletes the given objects from this Realm.
+
+    :param: object The objects to be deleted.
+    */
+    public func delete<S: SequenceType where S.Generator.Element: Object>(objects: S) {
+        for obj in objects {
+            delete(obj)
+        }
+    }
+
+    /**
+    Deletes all objects from this Realm.
+    */
+    public func deleteAll() {
+        RLMDeleteAllObjectsFromRealm(rlmRealm)
+    }
+
+    // MARK: Object Retrieval
+
+    /**
+    Returns all objects of the given type in the specified Realm default realm,
+    or in the default realm if the `realm` argument is omitted.
+
+    :param: type  The type of the objects to be returned.
+    :param: realm The Realm instance to query.
+                  The default Realm will be used if this argument is omitted.
+
+    :returns: Results with all objects of the given type in the given Realm.
+    */
+    public func objects<T: Object>(type: T.Type) -> Results<T> {
+        return Results<T>(RLMGetObjects(rlmRealm, T.className(), nil))
+    }
+
+
+    // MARK: Notifications
+
+    /**
+    Add a notification handler for changes in this Realm.
+
+    :param: block A block which is called to process Realm notifications.
+                  It receives the following parameters:
+
+                  - `Notification`: The incoming notification.
+                  - `Realm`:        The realm for which this notification occurred.
+
+    :returns: A notification token which can later be passed to `removeNotification(_:)`
+              to remove this notification.
+    */
+    public func addNotificationBlock(block: NotificationBlock) -> NotificationToken {
+        return rlmRealm.addNotificationBlock(rlmNotificationBlockFromNotificationBlock(block))
+    }
+
+    /**
+    Remove a previously registered notification handler using the token returned
+    from `addNotificationBlock(_:)`
+
+    :param: notificationToken The token returned from `addNotificationBlock(_:)`
+                              corresponding to the notification block to remove.
+    */
+    public func removeNotification(notificationToken: NotificationToken) {
+        rlmRealm.removeNotification(notificationToken)
+    }
+
 
     // MARK: Autorefresh and Refresh
 

        self.init(RLMRealm.inMemoryRealmWithIdentifier(inMemoryIdentifier))
    }

    // MARK: Writing a Copy

    /**
    Write an encrypted and compacted copy of the Realm to the given path.

    The destination file cannot already exist.

    Note that if this is called from within a write transaction it writes the
    *current* data, and not data when the last write transaction was committed.

    :param: path          Path to save the Realm to.
    :param: encryptionKey Optional 64-byte encryption key to encrypt the new file with.
    :returns:             If an error occurs, returns an `NSError` object, otherwise `nil`.

    :returns: Whether the realm was copied successfully.
    */
    public func writeCopyToPath(path: String, encryptionKey: NSData? = nil) -> NSError? {
        var error: NSError?
        if let encryptionKey = encryptionKey {
            rlmRealm.writeCopyToPath(path, encryptionKey: encryptionKey, error: &error)
        }
        else {
            rlmRealm.writeCopyToPath(path, error: &error)
        }
        return error
    }

    // MARK: Transactions

    /**

        rlmRealm.invalidate()
    }

    // MARK: Writing a Copy

    /**
    Write an encrypted and compacted copy of the Realm to the given path.

    The destination file cannot already exist.

    Note that if this is called from within a write transaction it writes the
    *current* data, and not data when the last write transaction was committed.

    :param: path          Path to save the Realm to.
    :param: encryptionKey Optional 64-byte encryption key to encrypt the new file with.
    :returns:             If an error occurs, returns an `NSError` object, otherwise `nil`.

    :returns: Whether the realm was copied successfully.
    */
    public func writeCopyToPath(path: String, encryptionKey: NSData? = nil) -> NSError? {
        var error: NSError?
        if let encryptionKey = encryptionKey {
            rlmRealm.writeCopyToPath(path, encryptionKey: encryptionKey, error: &error)
        }
        else {
            rlmRealm.writeCopyToPath(path, error: &error)
        }
        return error
    }

    // MARK: Encryption

    /**
    Set the encryption key to use when opening Realms at a certain path.

