RealmObject (Realm 1.1.0)

java.lang.Object
- io.realm.RealmObject

All Implemented Interfaces:

RealmModel

Direct Known Subclasses:

DynamicRealmObject
```
public abstract class RealmObject
extends java.lang.Object
implements RealmModel
```
In Realm you define your RealmObject classes by sub-classing RealmObject and adding fields to be persisted. You then create your objects within a Realm, and use your custom subclasses instead of using the RealmObject class directly.
An annotation processor will create a proxy class for your RealmObject subclass.
The following field data types are supported:
- boolean/Boolean
- short/Short
- int/Integer
- long/Long
- float/Float
- double/Double
- byte[]
- String
- Date
- Any RealmObject subclass
- RealmList
The types short, int, and long are mapped to long when storing within a Realm.
The only restriction a RealmObject has is that fields are not allowed to be final, transient' or volatile. Any method as well as public fields are allowed. When providing custom constructors, a public constructor with no arguments must be declared and be empty.
Fields annotated with Ignore don't have these restrictions and don't require either a getter or setter.
Realm will create indexes for fields annotated with Index. This will speedup queries but will have a negative impact on inserts and updates.
A RealmObject cannot be passed between different threads.
See Also:

Realm.createObject(Class), Realm.copyToRealm(RealmModel)

Constructor Summary

Constructors
Constructor and Description

RealmObject()

Constructors
Constructor and Description
`RealmObject()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`static <E extends RealmModel> void`	`addChangeListener(E object, RealmChangeListener<E> listener)` Adds a change listener to a RealmObject.
`<E extends RealmModel> void`	`addChangeListener(RealmChangeListener<E> listener)` Adds a change listener to this RealmObject.
`<E extends RealmObject> <any>`	`asObservable()` Returns an RxJava Observable that monitors changes to this RealmObject.
`static <E extends RealmModel> <any>`	`asObservable(E object)` Returns an RxJava Observable that monitors changes to this RealmObject.
`void`	`deleteFromRealm()` Deletes the object from the Realm it is currently associated to.
`static <E extends RealmModel> void`	`deleteFromRealm(E object)` Deletes the object from the Realm it is currently associated with.
`boolean`	`isLoaded()` Determines if the current RealmObject is obtained synchronously or asynchronously (from a worker thread).
`static <E extends RealmModel> boolean`	`isLoaded(E object)` Determines if the RealmObject is obtained synchronously or asynchronously (from a worker thread).
`boolean`	`isValid()` Checks if the RealmObject is still valid to use i.e., the RealmObject hasn't been deleted nor has the `Realm` been closed.
`static <E extends RealmModel> boolean`	`isValid(E object)` Checks if the RealmObject is still valid to use i.e., the RealmObject hasn't been deleted nor has the `Realm` been closed.
`boolean`	`load()` Makes an asynchronous query blocking.
`static <E extends RealmModel> boolean`	`load(E object)` Makes an asynchronous query blocking.
`static <E extends RealmModel> void`	`removeChangeListener(E object, RealmChangeListener listener)` Removes a previously registered listener on the given RealmObject.
`void`	`removeChangeListener(RealmChangeListener listener)` Removes a previously registered listener.
`void`	`removeChangeListeners()` Removes all registered listeners.
`static <E extends RealmModel> void`	`removeChangeListeners(E object)` Removes all registered listeners from the given RealmObject.

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - RealmObject
```
public RealmObject()
```
- Method Detail
  - deleteFromRealm
```
public final void deleteFromRealm()
```
    Deletes the object from the Realm it is currently associated to.
    After this method is called the object will be invalid and any operation (read or write) performed on it will fail with an IllegalStateException.
    
    Throws:
    
    java.lang.IllegalStateException - if the corresponding Realm is closed or in an incorrect thread.
    
    See Also:
    
    isValid()
  - deleteFromRealm
```
public static <E extends RealmModel> void deleteFromRealm(E object)
```
    Deletes the object from the Realm it is currently associated with.
    After this method is called the object will be invalid and any operation (read or write) performed on it will fail with an IllegalStateException.
    
    Throws:
    
    java.lang.IllegalStateException - if the corresponding Realm is closed or in an incorrect thread.
    
    See Also:
    
    isValid()
  - isValid
```
public final boolean isValid()
```
    Checks if the RealmObject is still valid to use i.e., the RealmObject hasn't been deleted nor has the Realm been closed. It will always return false for unmanaged objects.
    Note that this can be used to check the validity of certain conditions such as being null when observed.
```
 
 realm.where(BannerRealm.class).equalTo("type", type).findFirstAsync().asObservable()
      .filter(result.isLoaded() && result.isValid())
      .first()
 
 
```
    Returns:
    
    true if the object is still accessible, false otherwise or if it is an unmanaged object.
    
    See Also:
    
    Examples using Realm with RxJava
  - isValid
```
public static <E extends RealmModel> boolean isValid(E object)
```
    Checks if the RealmObject is still valid to use i.e., the RealmObject hasn't been deleted nor has the Realm been closed. It will always return false for unmanaged objects.
    
    Parameters:
    
    object - RealmObject to check validity for.
    
    Returns:
    
    true if the object is still accessible, false otherwise or if it is an unmanaged object.
  - isLoaded
```
public final boolean isLoaded()
```
    Determines if the current RealmObject is obtained synchronously or asynchronously (from a worker thread). Synchronous RealmObjects are by definition blocking hence this method will always return true for them. This will return true if called for an unmanaged object (created outside of Realm).
    
    Returns:
    
    true if the query has completed and the data is available false if the query is in progress.
  - isLoaded
```
public static <E extends RealmModel> boolean isLoaded(E object)
```
    Determines if the RealmObject is obtained synchronously or asynchronously (from a worker thread). Synchronous RealmObjects are by definition blocking hence this method will always return true for them. This will return true if called for an unmanaged object (created outside of Realm).
    
    Parameters:
    
    object - RealmObject to check.
    
    Returns:
    
    true if the query has completed and the data is available false if the query is in progress.
  - load
```
public final boolean load()
```
    Makes an asynchronous query blocking. This will also trigger any registered listeners.
    Note: This will return true if called for an unmanaged object (created outside of Realm).
    
    Returns:
    
    true if it successfully completed the query, false otherwise.
  - load
```
public static <E extends RealmModel> boolean load(E object)
```
    Makes an asynchronous query blocking. This will also trigger any registered listeners.
    Note: This will return true if called for an unmanaged object (created outside of Realm).
    
    Parameters:
    
    object - RealmObject to force load.
    
    Returns:
    
    true if it successfully completed the query, false otherwise.
  - addChangeListener
```
public final <E extends RealmModel> void addChangeListener(RealmChangeListener<E> listener)
```
    Adds a change listener to this RealmObject.
    
    Parameters:
    
    listener - the change listener to be notified.
    
    Throws:
    
    java.lang.IllegalArgumentException - if the change listener is null or the object is an unmanaged object.
    
    java.lang.IllegalArgumentException - if object is an unmanaged RealmObject.
  - addChangeListener
```
public static <E extends RealmModel> void addChangeListener(E object,
                                                            RealmChangeListener<E> listener)
```
    Adds a change listener to a RealmObject.
    
    Parameters:
    
    object - RealmObject to add listener to.
    
    listener - the change listener to be notified.
    
    Throws:
    
    java.lang.IllegalArgumentException - if the object or the change listener is null.
    
    java.lang.IllegalArgumentException - if object is an unmanaged RealmObject.
    
    java.lang.IllegalStateException - if you try to add a listener from a non-Looper Thread.
  - removeChangeListener
```
public final void removeChangeListener(RealmChangeListener listener)
```
    Removes a previously registered listener.
    
    Parameters:
    
    listener - the instance to be removed.
    
    Throws:
    
    java.lang.IllegalArgumentException - if the change listener is null or the object is an unmanaged object.
    
    java.lang.IllegalStateException - if you try to remove a listener from a non-Looper Thread.
  - removeChangeListener
```
public static <E extends RealmModel> void removeChangeListener(E object,
                                                               RealmChangeListener listener)
```
    Removes a previously registered listener on the given RealmObject.
    
    Parameters:
    
    object - RealmObject to remove listener from.
    
    listener - the instance to be removed.
    
    Throws:
    
    java.lang.IllegalArgumentException - if the object or the change listener is null.
    
    java.lang.IllegalArgumentException - if object is an unmanaged RealmObject.
    
    java.lang.IllegalStateException - if you try to remove a listener from a non-Looper Thread.
  - removeChangeListeners
```
public final void removeChangeListeners()
```
    Removes all registered listeners.
  - removeChangeListeners
```
public static <E extends RealmModel> void removeChangeListeners(E object)
```
    Removes all registered listeners from the given RealmObject.
    
    Parameters:
    
    object - RealmObject to remove all listeners from.
    
    Throws:
    
    java.lang.IllegalArgumentException - if object is null or isn't managed by Realm.
  - asObservable
```
public final <E extends RealmObject> <any> asObservable()
```
    Returns an RxJava Observable that monitors changes to this RealmObject. It will emit the current object when subscribed to. Object updates will continually be emitted as the RealmObject is updated - onComplete will never be called.
    When chaining a RealmObject observable use obj.<MyRealmObjectClass>asObservable() to pass on type information, otherwise the type of the following observables will be RealmObject.
    If you would like the asObservable() to stop emitting items you can instruct RxJava to only emit only the first item by using the first() operator:
```
 
 obj.asObservable()
      .filter(obj -> obj.isLoaded())
      .first()
      .subscribe( ... ) // You only get the object once
 
 
```
    Note that when the Realm is accessed from threads other than where it was created, IllegalStateException will be thrown. Care should be taken when using different schedulers with subscribeOn() and observeOn(). Consider using Realm.where().find*Async() instead.
    Type Parameters:
    
    E - RealmObject class that is being observed. Must be this class or its super types.
    
    Returns:
    
    RxJava Observable that only calls onNext. It will never call onComplete or OnError.
    
    Throws:
    
    java.lang.UnsupportedOperationException - if the required RxJava framework is not on the classpath or the corresponding Realm instance doesn't support RxJava.
    
    See Also:
    
    RxJava and Realm
  - asObservable
```
public static <E extends RealmModel> <any> asObservable(E object)
```
    Returns an RxJava Observable that monitors changes to this RealmObject. It will emit the current object when subscribed to. Object updates will continuously be emitted as the RealmObject is updated - onComplete will never be called.
    When chaining a RealmObject observable use obj.<MyRealmObjectClass>asObservable() to pass on type information, otherwise the type of the following observables will be RealmObject.
    If you would like the asObservable() to stop emitting items you can instruct RxJava to emit only the first item by using the first() operator:
```
 
 obj.asObservable()
      .filter(obj -> obj.isLoaded())
      .first()
      .subscribe( ... ) // You only get the object once
 
 
```
    Parameters:
    
    object - RealmObject class that is being observed. Must be this class or its super types.
    
    Returns:
    
    RxJava Observable that only calls onNext. It will never call onComplete or OnError.
    
    Throws:
    
    java.lang.UnsupportedOperationException - if the required RxJava framework is not on the classpath.
    
    See Also:
    
    RxJava and Realm

Class RealmObject

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

RealmObject

Method Detail

deleteFromRealm

deleteFromRealm

isValid

isValid

isLoaded

isLoaded

load

load

addChangeListener

addChangeListener

removeChangeListener

removeChangeListener

removeChangeListeners

removeChangeListeners

asObservable

asObservable