internal RealmObject MakeObjectForRow(Type objectType, RowHandle rowHandle)
{
RealmObject ret = Metadata[objectType].Helper.CreateInstance();
ret._Manage(this, rowHandle);
return(ret);
}
private void AddObjectToRealmIfNeeded(RealmObject obj)
{
if (!obj.IsManaged)
{
_realm.Add(obj);
}
}
internal RealmObject MakeObjectForRow(RealmObject.Metadata metadata, RowHandle row)
{
RealmObject ret = metadata.Helper.CreateInstance();
ret._Manage(this, row, metadata);
return(ret);
}
private void AddInternal(RealmObject obj, Type objectType, bool update)
{
if (obj == null)
{
throw new ArgumentNullException(nameof(obj));
}
if (objectType == null)
{
throw new ArgumentNullException(nameof(objectType));
}
if (obj.IsManaged)
{
if (obj.Realm.SharedRealmHandle == this.SharedRealmHandle)
{
// Already managed by this realm, so nothing to do.
return;
}
throw new RealmObjectManagedByAnotherRealmException("Cannot start to manage an object with a realm when it's already managed by another realm");
}
if (!Metadata.TryGetValue(objectType.Name, out var metadata))
{
throw new ArgumentException($"The class {objectType.Name} is not in the limited set of classes for this realm");
}
var objectPtr = IntPtr.Zero;
if (update && metadata.Helper.TryGetPrimaryKeyValue(obj, out var pkValue))
{
switch (pkValue)
{
case string stringValue:
objectPtr = metadata.Table.Find(SharedRealmHandle, stringValue);
break;
case null:
objectPtr = metadata.Table.Find(SharedRealmHandle, (long?)null);
break;
default:
// We know it must be convertible to long, so optimistically do it.
objectPtr = metadata.Table.Find(SharedRealmHandle, Convert.ToInt64(pkValue));
break;
}
}
var setPrimaryKey = false;
if (objectPtr == IntPtr.Zero)
{
objectPtr = metadata.Table.AddEmptyObject(SharedRealmHandle);
setPrimaryKey = true;
}
var objectHandle = CreateObjectHandle(objectPtr, SharedRealmHandle);
obj._SetOwner(this, objectHandle, metadata);
metadata.Helper.CopyToRealm(obj, update, setPrimaryKey);
obj.OnManaged();
}
/// <summary>
/// This <see cref="Realm"/> will start managing a <see cref="RealmObject"/> which has been created as a standalone object.
/// </summary>
/// <param name="obj">Must be a standalone object, <c>null</c> not allowed.</param>
/// <param name="update">If <c>true</c>, and an object with the same primary key already exists, performs an update.</param>
/// <exception cref="RealmInvalidTransactionException">
/// If you invoke this when there is no write <see cref="Transaction"/> active on the <see cref="Realm"/>.
/// </exception>
/// <exception cref="RealmObjectManagedByAnotherRealmException">
/// You can't manage an object with more than one <see cref="Realm"/>.
/// </exception>
/// <remarks>
/// If the object is already managed by this <see cref="Realm"/>, this method does nothing.
/// This method modifies the object in-place, meaning that after it has run, <c>obj</c> will be managed.
/// Cyclic graphs (<c>Parent</c> has <c>Child</c> that has a <c>Parent</c>) will result in undefined behavior.
/// You have to break the cycle manually and assign relationships after all object have been managed.
/// </remarks>
/// <returns>The passed object.</returns>
public RealmObject Add(RealmObject obj, bool update = false)
{
ThrowIfDisposed();
AddInternal(obj, obj?.GetType(), update);
return(obj);
}
/// <summary>
/// Removes a persistent object from this Realm, effectively deleting it.
/// </summary>
/// <param name="obj">Must be an object persisted in this Realm.</param>
/// <exception cref="RealmInvalidTransactionException">
/// If you invoke this when there is no write <see cref="Transaction"/> active on the <see cref="Realm"/>.
/// </exception>
/// <exception cref="ArgumentNullException">If <c>obj</c> is <c>null</c>.</exception>
/// <exception cref="ArgumentException">If you pass a standalone object.</exception>
public void Remove(RealmObject obj)
{
ThrowIfDisposed();
Argument.NotNull(obj, nameof(obj));
Argument.Ensure(obj.IsManaged, "Object is not managed by Realm, so it cannot be removed.", nameof(obj));
obj.ObjectHandle.RemoveFromRealm(SharedRealmHandle);
}
private void AddInternal(RealmObject obj, Type objectType, bool update)
{
if (obj == null)
{
throw new ArgumentNullException(nameof(obj));
}
if (objectType == null)
{
throw new ArgumentNullException(nameof(objectType));
}
if (obj.IsManaged)
{
if (obj.Realm.SharedRealmHandle == this.SharedRealmHandle)
{
// Already managed by this realm, so nothing to do.
return;
}
throw new RealmObjectManagedByAnotherRealmException("Cannot start to manage an object with a realm when it's already managed by another realm");
}
var metadata = Metadata[objectType.Name];
var objectPtr = IntPtr.Zero;
object pkValue;
if (update && metadata.Helper.TryGetPrimaryKeyValue(obj, out pkValue))
{
if (pkValue is string)
{
objectPtr = metadata.Table.Find(SharedRealmHandle, (string)pkValue);
}
else if (pkValue == null)
{
objectPtr = metadata.Table.Find(SharedRealmHandle, (long?)null);
}
else
{
// We know it must be convertible to long, so optimistically do it.
objectPtr = metadata.Table.Find(SharedRealmHandle, Convert.ToInt64(pkValue));
}
}
if (objectPtr == IntPtr.Zero)
{
objectPtr = metadata.Table.AddEmptyObject(SharedRealmHandle);
}
var objectHandle = CreateObjectHandle(objectPtr, SharedRealmHandle);
obj._SetOwner(this, objectHandle, metadata);
metadata.Helper.CopyToRealm(obj, update);
}
/// <summary>
/// Removes a persistent object from this realm, effectively deleting it.
/// </summary>
/// <param name="obj">Must be an object persisted in this realm.</param>
/// <exception cref="RealmOutsideTransactionException">If you invoke this when there is no write Transaction active on the realm.</exception>
/// <exception cref="System.ArgumentNullException">If you invoke this with a standalone object.</exception>
public void Remove(RealmObject obj)
{
if (!IsInTransaction)
{
throw new RealmOutsideTransactionException("Cannot remove Realm object outside write transactions");
}
var tableHandle = Metadata[obj.GetType()].Table;
NativeTable.remove_row(tableHandle, (RowHandle)obj.RowHandle);
}
/// <summary>
/// Removes a persistent object from this realm, effectively deleting it.
/// </summary>
/// <param name="obj">Must be an object persisted in this realm.</param>
/// <exception cref="RealmInvalidTransactionException">If you invoke this when there is no write Transaction active on the realm.</exception>
/// <exception cref="ArgumentNullException">If you invoke this with a standalone object.</exception>
public void Remove(RealmObject obj)
{
if (obj == null)
{
throw new ArgumentNullException(nameof(obj));
}
if (!obj.IsManaged)
{
throw new ArgumentException("Object is not managed by Realm, so it cannot be removed.", nameof(obj));
}
obj.ObjectHandle.RemoveFromRealm(SharedRealmHandle);
}
private void AddInternal(RealmObject obj, Type objectType, bool update)
{
if (obj == null)
{
throw new ArgumentNullException(nameof(obj));
}
if (objectType == null)
{
throw new ArgumentNullException(nameof(objectType));
}
if (obj.IsManaged)
{
if (obj.Realm.SharedRealmHandle == this.SharedRealmHandle)
{
// Already managed by this realm, so nothing to do.
return;
}
throw new RealmObjectManagedByAnotherRealmException("Cannot start to manage an object with a realm when it's already managed by another realm");
}
var objectName = objectType.GetTypeInfo().GetMappedOrOriginalName();
if (!Metadata.TryGetValue(objectName, out var metadata))
{
throw new ArgumentException($"The class {objectType.Name} is not in the limited set of classes for this realm");
}
ObjectHandle objectHandle;
bool isNew;
if (metadata.Helper.TryGetPrimaryKeyValue(obj, out var primaryKey))
{
var pkProperty = metadata.Schema.PrimaryKeyProperty.Value;
objectHandle = SharedRealmHandle.CreateObjectWithPrimaryKey(pkProperty, primaryKey, metadata.Table, objectName, update, out isNew);
}
else
{
isNew = true; // Objects without PK are always new
objectHandle = SharedRealmHandle.CreateObject(metadata.Table);
}
obj._SetOwner(this, objectHandle, metadata);
// If an object is newly created, we don't need to invoke setters of properties with default values.
metadata.Helper.CopyToRealm(obj, update, isNew);
obj.OnManaged();
}
public void SetObject(Realm realm, IntPtr propertyIndex, RealmObject @object)
{
if (@object == null)
{
this.ClearLink(propertyIndex);
}
else
{
if ([email protected])
{
realm.Add(@object);
}
this.SetLink(propertyIndex, @object.ObjectHandle);
}
}
public static void SetObject(Realm realm, TableHandle table, IntPtr columnIndex, IntPtr rowIndex, RealmObject @object)
{
if (@object == null)
{
NativeTable.ClearLink(table, columnIndex, rowIndex);
}
else
{
if ([email protected])
{
realm.Manage(@object);
}
NativeTable.SetLink(table, columnIndex, rowIndex, @object.RowHandle.RowIndex);
}
}
/// <summary>
/// Removes a persistent object from this Realm, effectively deleting it.
/// </summary>
/// <param name="obj">Must be an object persisted in this Realm.</param>
/// <exception cref="RealmInvalidTransactionException">
/// If you invoke this when there is no write <see cref="Transaction"/> active on the <see cref="Realm"/>.
/// </exception>
/// <exception cref="ArgumentNullException">If <c>obj</c> is <c>null</c>.</exception>
/// <exception cref="ArgumentException">If you pass a standalone object.</exception>
public void Remove(RealmObject obj)
{
RealmPCLHelpers.ThrowProxyShouldNeverBeUsed();
}
/// <summary>
/// This <see cref="Realm"/> will start managing a <see cref="RealmObject"/> which has been created as a standalone object.
/// </summary>
/// <param name="obj">Must be a standalone object, <c>null</c> not allowed.</param>
/// <param name="update">If <c>true</c>, and an object with the same primary key already exists, performs an update.</param>
/// <exception cref="RealmInvalidTransactionException">
/// If you invoke this when there is no write <see cref="Transaction"/> active on the <see cref="Realm"/>.
/// </exception>
/// <exception cref="RealmObjectManagedByAnotherRealmException">
/// You can't manage an object with more than one <see cref="Realm"/>.
/// </exception>
/// <remarks>
/// If the object is already managed by this <see cref="Realm"/>, this method does nothing.
/// This method modifies the object in-place, meaning that after it has run, <c>obj</c> will be managed.
/// Cyclic graphs (<c>Parent</c> has <c>Child</c> that has a <c>Parent</c>) will result in undefined behavior.
/// You have to break the cycle manually and assign relationships after all object have been managed.
/// </remarks>
/// <returns>The passed object.</returns>
public RealmObject Add(RealmObject obj, bool update = false)
{
RealmPCLHelpers.ThrowProxyShouldNeverBeUsed();
return(null);
}
/// <summary>
/// This realm will start managing a RealmObject which has been created as a standalone object.
/// </summary>
/// <param name="obj">Must be a standalone object, null not allowed.</param>
/// <param name="update">If true, and an object with the same primary key already exists, performs an update.</param>
/// <exception cref="RealmInvalidTransactionException">If you invoke this when there is no write Transaction active on the realm.</exception>
/// <exception cref="RealmObjectManagedByAnotherRealmException">You can't manage an object with more than one realm</exception>
/// <remarks>
/// If the object is already managed by this realm, this method does nothing.
/// Cyclic graphs (<c>Parent</c> has <c>Child</c> that has a <c>Parent</c>) will result in undefined behavior. You have to break the cycle manually and assign relationships after all object have been managed.
/// </remarks>
public void Add(RealmObject obj, bool update = false)
{
AddInternal(obj, obj?.GetType(), update);
}
public RealmObject Add(RealmObject obj, bool update)
{
return(null);
}
/// <summary>
/// This realm will start managing a RealmObject which has been created as a standalone object.
/// </summary>
/// <param name="obj">Must be a standalone object, null not allowed.</param>
/// <param name="update">If true, and an object with the same primary key already exists, performs an update.</param>
/// <exception cref="RealmInvalidTransactionException">If you invoke this when there is no write Transaction active on the realm.</exception>
/// <exception cref="RealmObjectManagedByAnotherRealmException">You can't manage an object with more than one realm</exception>
/// <remarks>
/// If the object is already managed by this realm, this method does nothing.
/// Cyclic graphs (<c>Parent</c> has <c>Child</c> that has a <c>Parent</c>) will result in undefined behavior. You have to break the cycle manually and assign relationships after all object have been managed.
/// </remarks>
public void Add(RealmObject obj, bool update = false)
{
RealmPCLHelpers.ThrowProxyShouldNeverBeUsed();
}
internal RealmList(RealmObject parent, LinkListHandle adoptedList)
{
_parent = parent;
_listHandle = adoptedList;
}