805 lines
26 KiB
C#
805 lines
26 KiB
C#
using CPF.Mac.Foundation;
|
|
using CPF.Mac.ObjCRuntime;
|
|
using System;
|
|
using System.ComponentModel;
|
|
using System.Runtime.InteropServices;
|
|
|
|
namespace CPF.Mac.CoreData
|
|
{
|
|
[Register("NSManagedObjectContext", true)]
|
|
public class NSManagedObjectContext : NSObject
|
|
{
|
|
private static readonly IntPtr selPersistentStoreCoordinatorHandle = Selector.GetHandle("persistentStoreCoordinator");
|
|
|
|
private static readonly IntPtr selSetPersistentStoreCoordinator_Handle = Selector.GetHandle("setPersistentStoreCoordinator:");
|
|
|
|
private static readonly IntPtr selUndoManagerHandle = Selector.GetHandle("undoManager");
|
|
|
|
private static readonly IntPtr selSetUndoManager_Handle = Selector.GetHandle("setUndoManager:");
|
|
|
|
private static readonly IntPtr selHasChangesHandle = Selector.GetHandle("hasChanges");
|
|
|
|
private static readonly IntPtr selInsertedObjectsHandle = Selector.GetHandle("insertedObjects");
|
|
|
|
private static readonly IntPtr selUpdatedObjectsHandle = Selector.GetHandle("updatedObjects");
|
|
|
|
private static readonly IntPtr selDeletedObjectsHandle = Selector.GetHandle("deletedObjects");
|
|
|
|
private static readonly IntPtr selRegisteredObjectsHandle = Selector.GetHandle("registeredObjects");
|
|
|
|
private static readonly IntPtr selTryLockHandle = Selector.GetHandle("tryLock");
|
|
|
|
private static readonly IntPtr selPropagatesDeletesAtEndOfEventHandle = Selector.GetHandle("propagatesDeletesAtEndOfEvent");
|
|
|
|
private static readonly IntPtr selSetPropagatesDeletesAtEndOfEvent_Handle = Selector.GetHandle("setPropagatesDeletesAtEndOfEvent:");
|
|
|
|
private static readonly IntPtr selRetainsRegisteredObjectsHandle = Selector.GetHandle("retainsRegisteredObjects");
|
|
|
|
private static readonly IntPtr selSetRetainsRegisteredObjects_Handle = Selector.GetHandle("setRetainsRegisteredObjects:");
|
|
|
|
private static readonly IntPtr selStalenessIntervalHandle = Selector.GetHandle("stalenessInterval");
|
|
|
|
private static readonly IntPtr selSetStalenessInterval_Handle = Selector.GetHandle("setStalenessInterval:");
|
|
|
|
private static readonly IntPtr selMergePolicyHandle = Selector.GetHandle("mergePolicy");
|
|
|
|
private static readonly IntPtr selSetMergePolicy_Handle = Selector.GetHandle("setMergePolicy:");
|
|
|
|
private static readonly IntPtr selUserInfoHandle = Selector.GetHandle("userInfo");
|
|
|
|
private static readonly IntPtr selConcurrencyTypeHandle = Selector.GetHandle("concurrencyType");
|
|
|
|
private static readonly IntPtr selParentContextHandle = Selector.GetHandle("parentContext");
|
|
|
|
private static readonly IntPtr selSetParentContext_Handle = Selector.GetHandle("setParentContext:");
|
|
|
|
private static readonly IntPtr selObjectRegisteredForID_Handle = Selector.GetHandle("objectRegisteredForID:");
|
|
|
|
private static readonly IntPtr selObjectWithID_Handle = Selector.GetHandle("objectWithID:");
|
|
|
|
private static readonly IntPtr selExecuteFetchRequestError_Handle = Selector.GetHandle("executeFetchRequest:error:");
|
|
|
|
private static readonly IntPtr selCountForFetchRequestError_Handle = Selector.GetHandle("countForFetchRequest:error:");
|
|
|
|
private static readonly IntPtr selInsertObject_Handle = Selector.GetHandle("insertObject:");
|
|
|
|
private static readonly IntPtr selDeleteObject_Handle = Selector.GetHandle("deleteObject:");
|
|
|
|
private static readonly IntPtr selRefreshObjectMergeChanges_Handle = Selector.GetHandle("refreshObject:mergeChanges:");
|
|
|
|
private static readonly IntPtr selDetectConflictsForObject_Handle = Selector.GetHandle("detectConflictsForObject:");
|
|
|
|
private static readonly IntPtr selObserveValueForKeyPathOfObjectChangeContext_Handle = Selector.GetHandle("observeValueForKeyPath:ofObject:change:context:");
|
|
|
|
private static readonly IntPtr selProcessPendingChangesHandle = Selector.GetHandle("processPendingChanges");
|
|
|
|
private static readonly IntPtr selAssignObjectToPersistentStore_Handle = Selector.GetHandle("assignObject:toPersistentStore:");
|
|
|
|
private static readonly IntPtr selUndoHandle = Selector.GetHandle("undo");
|
|
|
|
private static readonly IntPtr selRedoHandle = Selector.GetHandle("redo");
|
|
|
|
private static readonly IntPtr selResetHandle = Selector.GetHandle("reset");
|
|
|
|
private static readonly IntPtr selRollbackHandle = Selector.GetHandle("rollback");
|
|
|
|
private static readonly IntPtr selSave_Handle = Selector.GetHandle("save:");
|
|
|
|
private static readonly IntPtr selLockHandle = Selector.GetHandle("lock");
|
|
|
|
private static readonly IntPtr selUnlockHandle = Selector.GetHandle("unlock");
|
|
|
|
private static readonly IntPtr selObtainPermanentIDsForObjectsError_Handle = Selector.GetHandle("obtainPermanentIDsForObjects:error:");
|
|
|
|
private static readonly IntPtr selMergeChangesFromContextDidSaveNotification_Handle = Selector.GetHandle("mergeChangesFromContextDidSaveNotification:");
|
|
|
|
private static readonly IntPtr selInitWithConcurrencyType_Handle = Selector.GetHandle("initWithConcurrencyType:");
|
|
|
|
private static readonly IntPtr selPerformBlock_Handle = Selector.GetHandle("performBlock:");
|
|
|
|
private static readonly IntPtr selPerformBlockAndWait_Handle = Selector.GetHandle("performBlockAndWait:");
|
|
|
|
private static readonly IntPtr class_ptr = Class.GetHandle("NSManagedObjectContext");
|
|
|
|
private object __mt_PersistentStoreCoordinator_var;
|
|
|
|
private object __mt_UndoManager_var;
|
|
|
|
private object __mt_InsertedObjects_var;
|
|
|
|
private object __mt_UpdatedObjects_var;
|
|
|
|
private object __mt_DeletedObjects_var;
|
|
|
|
private object __mt_RegisteredObjects_var;
|
|
|
|
private object __mt_UserInfo_var;
|
|
|
|
private object __mt_ParentContext_var;
|
|
|
|
public override IntPtr ClassHandle => class_ptr;
|
|
|
|
public virtual NSPersistentStoreCoordinator PersistentStoreCoordinator
|
|
{
|
|
[Export("persistentStoreCoordinator")]
|
|
get
|
|
{
|
|
return (NSPersistentStoreCoordinator)(__mt_PersistentStoreCoordinator_var = ((!IsDirectBinding) ? ((NSPersistentStoreCoordinator)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selPersistentStoreCoordinatorHandle))) : ((NSPersistentStoreCoordinator)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend(base.Handle, selPersistentStoreCoordinatorHandle)))));
|
|
}
|
|
[Export("setPersistentStoreCoordinator:")]
|
|
set
|
|
{
|
|
if (value == null)
|
|
{
|
|
throw new ArgumentNullException("value");
|
|
}
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend_IntPtr(base.Handle, selSetPersistentStoreCoordinator_Handle, value.Handle);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper_IntPtr(base.SuperHandle, selSetPersistentStoreCoordinator_Handle, value.Handle);
|
|
}
|
|
__mt_PersistentStoreCoordinator_var = value;
|
|
}
|
|
}
|
|
|
|
public virtual NSUndoManager UndoManager
|
|
{
|
|
[Export("undoManager")]
|
|
get
|
|
{
|
|
return (NSUndoManager)(__mt_UndoManager_var = ((!IsDirectBinding) ? ((NSUndoManager)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selUndoManagerHandle))) : ((NSUndoManager)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend(base.Handle, selUndoManagerHandle)))));
|
|
}
|
|
[Export("setUndoManager:")]
|
|
set
|
|
{
|
|
if (value == null)
|
|
{
|
|
throw new ArgumentNullException("value");
|
|
}
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend_IntPtr(base.Handle, selSetUndoManager_Handle, value.Handle);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper_IntPtr(base.SuperHandle, selSetUndoManager_Handle, value.Handle);
|
|
}
|
|
__mt_UndoManager_var = value;
|
|
}
|
|
}
|
|
|
|
public virtual bool HasChanges
|
|
{
|
|
[Export("hasChanges")]
|
|
get
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
return Messaging.bool_objc_msgSend(base.Handle, selHasChangesHandle);
|
|
}
|
|
return Messaging.bool_objc_msgSendSuper(base.SuperHandle, selHasChangesHandle);
|
|
}
|
|
}
|
|
|
|
public virtual NSSet InsertedObjects
|
|
{
|
|
[Export("insertedObjects")]
|
|
get
|
|
{
|
|
return (NSSet)(__mt_InsertedObjects_var = ((!IsDirectBinding) ? ((NSSet)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selInsertedObjectsHandle))) : ((NSSet)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend(base.Handle, selInsertedObjectsHandle)))));
|
|
}
|
|
}
|
|
|
|
public virtual NSSet UpdatedObjects
|
|
{
|
|
[Export("updatedObjects")]
|
|
get
|
|
{
|
|
return (NSSet)(__mt_UpdatedObjects_var = ((!IsDirectBinding) ? ((NSSet)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selUpdatedObjectsHandle))) : ((NSSet)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend(base.Handle, selUpdatedObjectsHandle)))));
|
|
}
|
|
}
|
|
|
|
public virtual NSSet DeletedObjects
|
|
{
|
|
[Export("deletedObjects")]
|
|
get
|
|
{
|
|
return (NSSet)(__mt_DeletedObjects_var = ((!IsDirectBinding) ? ((NSSet)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selDeletedObjectsHandle))) : ((NSSet)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend(base.Handle, selDeletedObjectsHandle)))));
|
|
}
|
|
}
|
|
|
|
public virtual NSSet RegisteredObjects
|
|
{
|
|
[Export("registeredObjects")]
|
|
get
|
|
{
|
|
return (NSSet)(__mt_RegisteredObjects_var = ((!IsDirectBinding) ? ((NSSet)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selRegisteredObjectsHandle))) : ((NSSet)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend(base.Handle, selRegisteredObjectsHandle)))));
|
|
}
|
|
}
|
|
|
|
public virtual bool TryLock
|
|
{
|
|
[Export("tryLock")]
|
|
get
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
return Messaging.bool_objc_msgSend(base.Handle, selTryLockHandle);
|
|
}
|
|
return Messaging.bool_objc_msgSendSuper(base.SuperHandle, selTryLockHandle);
|
|
}
|
|
}
|
|
|
|
public virtual bool PropagatesDeletesAtEndOfEvent
|
|
{
|
|
[Export("propagatesDeletesAtEndOfEvent")]
|
|
get
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
return Messaging.bool_objc_msgSend(base.Handle, selPropagatesDeletesAtEndOfEventHandle);
|
|
}
|
|
return Messaging.bool_objc_msgSendSuper(base.SuperHandle, selPropagatesDeletesAtEndOfEventHandle);
|
|
}
|
|
[Export("setPropagatesDeletesAtEndOfEvent:")]
|
|
set
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend_bool(base.Handle, selSetPropagatesDeletesAtEndOfEvent_Handle, value);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper_bool(base.SuperHandle, selSetPropagatesDeletesAtEndOfEvent_Handle, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
public virtual bool RetainsRegisteredObjects
|
|
{
|
|
[Export("retainsRegisteredObjects")]
|
|
get
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
return Messaging.bool_objc_msgSend(base.Handle, selRetainsRegisteredObjectsHandle);
|
|
}
|
|
return Messaging.bool_objc_msgSendSuper(base.SuperHandle, selRetainsRegisteredObjectsHandle);
|
|
}
|
|
[Export("setRetainsRegisteredObjects:")]
|
|
set
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend_bool(base.Handle, selSetRetainsRegisteredObjects_Handle, value);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper_bool(base.SuperHandle, selSetRetainsRegisteredObjects_Handle, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
public virtual double StalenessInterval
|
|
{
|
|
[Export("stalenessInterval")]
|
|
get
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
return Messaging.Double_objc_msgSend(base.Handle, selStalenessIntervalHandle);
|
|
}
|
|
return Messaging.Double_objc_msgSendSuper(base.SuperHandle, selStalenessIntervalHandle);
|
|
}
|
|
[Export("setStalenessInterval:")]
|
|
set
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend_Double(base.Handle, selSetStalenessInterval_Handle, value);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper_Double(base.SuperHandle, selSetStalenessInterval_Handle, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
public virtual IntPtr MergePolicy
|
|
{
|
|
[Export("mergePolicy")]
|
|
get
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
return Messaging.IntPtr_objc_msgSend(base.Handle, selMergePolicyHandle);
|
|
}
|
|
return Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selMergePolicyHandle);
|
|
}
|
|
[Export("setMergePolicy:")]
|
|
set
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend_IntPtr(base.Handle, selSetMergePolicy_Handle, value);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper_IntPtr(base.SuperHandle, selSetMergePolicy_Handle, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
public virtual NSMutableDictionary UserInfo
|
|
{
|
|
[Export("userInfo")]
|
|
get
|
|
{
|
|
return (NSMutableDictionary)(__mt_UserInfo_var = ((!IsDirectBinding) ? ((NSMutableDictionary)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selUserInfoHandle))) : ((NSMutableDictionary)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend(base.Handle, selUserInfoHandle)))));
|
|
}
|
|
}
|
|
|
|
public virtual NSManagedObjectContextConcurrencyType ConcurrencyType
|
|
{
|
|
[Export("concurrencyType")]
|
|
get
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
return (NSManagedObjectContextConcurrencyType)Messaging.UInt64_objc_msgSend(base.Handle, selConcurrencyTypeHandle);
|
|
}
|
|
return (NSManagedObjectContextConcurrencyType)Messaging.UInt64_objc_msgSendSuper(base.SuperHandle, selConcurrencyTypeHandle);
|
|
}
|
|
}
|
|
|
|
public virtual NSManagedObjectContext ParentContext
|
|
{
|
|
[Export("parentContext")]
|
|
get
|
|
{
|
|
return (NSManagedObjectContext)(__mt_ParentContext_var = ((!IsDirectBinding) ? ((NSManagedObjectContext)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, selParentContextHandle))) : ((NSManagedObjectContext)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend(base.Handle, selParentContextHandle)))));
|
|
}
|
|
[Export("setParentContext:")]
|
|
set
|
|
{
|
|
if (value == null)
|
|
{
|
|
throw new ArgumentNullException("value");
|
|
}
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend_IntPtr(base.Handle, selSetParentContext_Handle, value.Handle);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper_IntPtr(base.SuperHandle, selSetParentContext_Handle, value.Handle);
|
|
}
|
|
__mt_ParentContext_var = value;
|
|
}
|
|
}
|
|
|
|
[EditorBrowsable(EditorBrowsableState.Advanced)]
|
|
[Export("init")]
|
|
public NSManagedObjectContext()
|
|
: base(NSObjectFlag.Empty)
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
base.Handle = Messaging.IntPtr_objc_msgSend(base.Handle, Selector.Init);
|
|
}
|
|
else
|
|
{
|
|
base.Handle = Messaging.IntPtr_objc_msgSendSuper(base.SuperHandle, Selector.Init);
|
|
}
|
|
}
|
|
|
|
[EditorBrowsable(EditorBrowsableState.Advanced)]
|
|
[Export("initWithCoder:")]
|
|
public NSManagedObjectContext(NSCoder coder)
|
|
: base(NSObjectFlag.Empty)
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
base.Handle = Messaging.IntPtr_objc_msgSend_IntPtr(base.Handle, Selector.InitWithCoder, coder.Handle);
|
|
}
|
|
else
|
|
{
|
|
base.Handle = Messaging.IntPtr_objc_msgSendSuper_IntPtr(base.SuperHandle, Selector.InitWithCoder, coder.Handle);
|
|
}
|
|
}
|
|
|
|
[EditorBrowsable(EditorBrowsableState.Advanced)]
|
|
public NSManagedObjectContext(NSObjectFlag t)
|
|
: base(t)
|
|
{
|
|
}
|
|
|
|
[EditorBrowsable(EditorBrowsableState.Advanced)]
|
|
public NSManagedObjectContext(IntPtr handle)
|
|
: base(handle)
|
|
{
|
|
}
|
|
|
|
[Export("objectRegisteredForID:")]
|
|
public virtual NSManagedObject ObjectRegisteredForID(NSManagedObjectID objectID)
|
|
{
|
|
if (objectID == null)
|
|
{
|
|
throw new ArgumentNullException("objectID");
|
|
}
|
|
if (IsDirectBinding)
|
|
{
|
|
return (NSManagedObject)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend_IntPtr(base.Handle, selObjectRegisteredForID_Handle, objectID.Handle));
|
|
}
|
|
return (NSManagedObject)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSendSuper_IntPtr(base.SuperHandle, selObjectRegisteredForID_Handle, objectID.Handle));
|
|
}
|
|
|
|
[Export("objectWithID:")]
|
|
public virtual NSManagedObject ObjectWithID(NSManagedObjectID objectID)
|
|
{
|
|
if (objectID == null)
|
|
{
|
|
throw new ArgumentNullException("objectID");
|
|
}
|
|
if (IsDirectBinding)
|
|
{
|
|
return (NSManagedObject)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSend_IntPtr(base.Handle, selObjectWithID_Handle, objectID.Handle));
|
|
}
|
|
return (NSManagedObject)Runtime.GetNSObject(Messaging.IntPtr_objc_msgSendSuper_IntPtr(base.SuperHandle, selObjectWithID_Handle, objectID.Handle));
|
|
}
|
|
|
|
[Export("executeFetchRequest:error:")]
|
|
public virtual NSObject[] ExecuteFetchRequest(NSFetchRequest request, out NSError error)
|
|
{
|
|
if (request == null)
|
|
{
|
|
throw new ArgumentNullException("request");
|
|
}
|
|
IntPtr intPtr = Marshal.AllocHGlobal(4);
|
|
Marshal.WriteInt32(intPtr, 0);
|
|
NSObject[] result = (!IsDirectBinding) ? NSArray.ArrayFromHandle<NSObject>(Messaging.IntPtr_objc_msgSendSuper_IntPtr_IntPtr(base.SuperHandle, selExecuteFetchRequestError_Handle, request.Handle, intPtr)) : NSArray.ArrayFromHandle<NSObject>(Messaging.IntPtr_objc_msgSend_IntPtr_IntPtr(base.Handle, selExecuteFetchRequestError_Handle, request.Handle, intPtr));
|
|
IntPtr intPtr2 = Marshal.ReadIntPtr(intPtr);
|
|
error = ((intPtr2 != IntPtr.Zero) ? ((NSError)Runtime.GetNSObject(intPtr2)) : null);
|
|
Marshal.FreeHGlobal(intPtr);
|
|
return result;
|
|
}
|
|
|
|
[Export("countForFetchRequest:error:")]
|
|
public virtual uint CountForFetchRequest(NSFetchRequest request, out NSError error)
|
|
{
|
|
if (request == null)
|
|
{
|
|
throw new ArgumentNullException("request");
|
|
}
|
|
IntPtr intPtr = Marshal.AllocHGlobal(4);
|
|
Marshal.WriteInt32(intPtr, 0);
|
|
uint result = (!IsDirectBinding) ? Messaging.UInt32_objc_msgSendSuper_IntPtr_IntPtr(base.SuperHandle, selCountForFetchRequestError_Handle, request.Handle, intPtr) : Messaging.UInt32_objc_msgSend_IntPtr_IntPtr(base.Handle, selCountForFetchRequestError_Handle, request.Handle, intPtr);
|
|
IntPtr intPtr2 = Marshal.ReadIntPtr(intPtr);
|
|
error = ((intPtr2 != IntPtr.Zero) ? ((NSError)Runtime.GetNSObject(intPtr2)) : null);
|
|
Marshal.FreeHGlobal(intPtr);
|
|
return result;
|
|
}
|
|
|
|
[Export("insertObject:")]
|
|
public virtual void InsertObject(NSManagedObject object1)
|
|
{
|
|
if (object1 == null)
|
|
{
|
|
throw new ArgumentNullException("object1");
|
|
}
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend_IntPtr(base.Handle, selInsertObject_Handle, object1.Handle);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper_IntPtr(base.SuperHandle, selInsertObject_Handle, object1.Handle);
|
|
}
|
|
}
|
|
|
|
[Export("deleteObject:")]
|
|
public virtual void DeleteObject(NSManagedObject object1)
|
|
{
|
|
if (object1 == null)
|
|
{
|
|
throw new ArgumentNullException("object1");
|
|
}
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend_IntPtr(base.Handle, selDeleteObject_Handle, object1.Handle);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper_IntPtr(base.SuperHandle, selDeleteObject_Handle, object1.Handle);
|
|
}
|
|
}
|
|
|
|
[Export("refreshObject:mergeChanges:")]
|
|
public virtual void RefreshObject(NSManagedObject object1, bool flag)
|
|
{
|
|
if (object1 == null)
|
|
{
|
|
throw new ArgumentNullException("object1");
|
|
}
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend_IntPtr_bool(base.Handle, selRefreshObjectMergeChanges_Handle, object1.Handle, flag);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper_IntPtr_bool(base.SuperHandle, selRefreshObjectMergeChanges_Handle, object1.Handle, flag);
|
|
}
|
|
}
|
|
|
|
[Export("detectConflictsForObject:")]
|
|
public virtual void DetectConflictsForObject(NSManagedObject object1)
|
|
{
|
|
if (object1 == null)
|
|
{
|
|
throw new ArgumentNullException("object1");
|
|
}
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend_IntPtr(base.Handle, selDetectConflictsForObject_Handle, object1.Handle);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper_IntPtr(base.SuperHandle, selDetectConflictsForObject_Handle, object1.Handle);
|
|
}
|
|
}
|
|
|
|
[Export("observeValueForKeyPath:ofObject:change:context:")]
|
|
public virtual void ObserveValueForKeyPath(string keyPath, IntPtr object1, NSDictionary change, IntPtr context)
|
|
{
|
|
if (keyPath == null)
|
|
{
|
|
throw new ArgumentNullException("keyPath");
|
|
}
|
|
if (change == null)
|
|
{
|
|
throw new ArgumentNullException("change");
|
|
}
|
|
IntPtr intPtr = NSString.CreateNative(keyPath);
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend_IntPtr_IntPtr_IntPtr_IntPtr(base.Handle, selObserveValueForKeyPathOfObjectChangeContext_Handle, intPtr, object1, change.Handle, context);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper_IntPtr_IntPtr_IntPtr_IntPtr(base.SuperHandle, selObserveValueForKeyPathOfObjectChangeContext_Handle, intPtr, object1, change.Handle, context);
|
|
}
|
|
NSString.ReleaseNative(intPtr);
|
|
}
|
|
|
|
[Export("processPendingChanges")]
|
|
public virtual void ProcessPendingChanges()
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend(base.Handle, selProcessPendingChangesHandle);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper(base.SuperHandle, selProcessPendingChangesHandle);
|
|
}
|
|
}
|
|
|
|
[Export("assignObject:toPersistentStore:")]
|
|
public virtual void AssignObject(IntPtr object1, NSPersistentStore store)
|
|
{
|
|
if (store == null)
|
|
{
|
|
throw new ArgumentNullException("store");
|
|
}
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend_IntPtr_IntPtr(base.Handle, selAssignObjectToPersistentStore_Handle, object1, store.Handle);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper_IntPtr_IntPtr(base.SuperHandle, selAssignObjectToPersistentStore_Handle, object1, store.Handle);
|
|
}
|
|
}
|
|
|
|
[Export("undo")]
|
|
public virtual void Undo()
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend(base.Handle, selUndoHandle);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper(base.SuperHandle, selUndoHandle);
|
|
}
|
|
}
|
|
|
|
[Export("redo")]
|
|
public virtual void Redo()
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend(base.Handle, selRedoHandle);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper(base.SuperHandle, selRedoHandle);
|
|
}
|
|
}
|
|
|
|
[Export("reset")]
|
|
public virtual void Reset()
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend(base.Handle, selResetHandle);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper(base.SuperHandle, selResetHandle);
|
|
}
|
|
}
|
|
|
|
[Export("rollback")]
|
|
public virtual void Rollback()
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend(base.Handle, selRollbackHandle);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper(base.SuperHandle, selRollbackHandle);
|
|
}
|
|
}
|
|
|
|
[Export("save:")]
|
|
public virtual bool Save(out NSError error)
|
|
{
|
|
IntPtr intPtr = Marshal.AllocHGlobal(4);
|
|
Marshal.WriteInt32(intPtr, 0);
|
|
bool result = (!IsDirectBinding) ? Messaging.bool_objc_msgSendSuper_IntPtr(base.SuperHandle, selSave_Handle, intPtr) : Messaging.bool_objc_msgSend_IntPtr(base.Handle, selSave_Handle, intPtr);
|
|
IntPtr intPtr2 = Marshal.ReadIntPtr(intPtr);
|
|
error = ((intPtr2 != IntPtr.Zero) ? ((NSError)Runtime.GetNSObject(intPtr2)) : null);
|
|
Marshal.FreeHGlobal(intPtr);
|
|
return result;
|
|
}
|
|
|
|
[Export("lock")]
|
|
public virtual void Lock()
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend(base.Handle, selLockHandle);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper(base.SuperHandle, selLockHandle);
|
|
}
|
|
}
|
|
|
|
[Export("unlock")]
|
|
public virtual void Unlock()
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend(base.Handle, selUnlockHandle);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper(base.SuperHandle, selUnlockHandle);
|
|
}
|
|
}
|
|
|
|
[Export("obtainPermanentIDsForObjects:error:")]
|
|
public virtual bool ObtainPermanentIDsForObjects(NSManagedObject[] objects, out NSError error)
|
|
{
|
|
if (objects == null)
|
|
{
|
|
throw new ArgumentNullException("objects");
|
|
}
|
|
IntPtr intPtr = Marshal.AllocHGlobal(4);
|
|
Marshal.WriteInt32(intPtr, 0);
|
|
NSArray nSArray = NSArray.FromNSObjects(objects);
|
|
bool result = (!IsDirectBinding) ? Messaging.bool_objc_msgSendSuper_IntPtr_IntPtr(base.SuperHandle, selObtainPermanentIDsForObjectsError_Handle, nSArray.Handle, intPtr) : Messaging.bool_objc_msgSend_IntPtr_IntPtr(base.Handle, selObtainPermanentIDsForObjectsError_Handle, nSArray.Handle, intPtr);
|
|
nSArray.Dispose();
|
|
IntPtr intPtr2 = Marshal.ReadIntPtr(intPtr);
|
|
error = ((intPtr2 != IntPtr.Zero) ? ((NSError)Runtime.GetNSObject(intPtr2)) : null);
|
|
Marshal.FreeHGlobal(intPtr);
|
|
return result;
|
|
}
|
|
|
|
[Export("mergeChangesFromContextDidSaveNotification:")]
|
|
public virtual void MergeChangesFromContextDidSaveNotification(NSNotification notification)
|
|
{
|
|
if (notification == null)
|
|
{
|
|
throw new ArgumentNullException("notification");
|
|
}
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend_IntPtr(base.Handle, selMergeChangesFromContextDidSaveNotification_Handle, notification.Handle);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper_IntPtr(base.SuperHandle, selMergeChangesFromContextDidSaveNotification_Handle, notification.Handle);
|
|
}
|
|
}
|
|
|
|
[Export("initWithConcurrencyType:")]
|
|
public NSManagedObjectContext(NSManagedObjectContextConcurrencyType ct)
|
|
: base(NSObjectFlag.Empty)
|
|
{
|
|
if (IsDirectBinding)
|
|
{
|
|
base.Handle = Messaging.IntPtr_objc_msgSend_UInt64(base.Handle, selInitWithConcurrencyType_Handle, (ulong)ct);
|
|
}
|
|
else
|
|
{
|
|
base.Handle = Messaging.IntPtr_objc_msgSendSuper_UInt64(base.SuperHandle, selInitWithConcurrencyType_Handle, (ulong)ct);
|
|
}
|
|
}
|
|
|
|
[Export("performBlock:")]
|
|
public unsafe virtual void Perform(NSAction action)
|
|
{
|
|
if (action == null)
|
|
{
|
|
throw new ArgumentNullException("action");
|
|
}
|
|
BlockLiteral blockLiteral = default(BlockLiteral);
|
|
BlockLiteral* ptr = &blockLiteral;
|
|
blockLiteral.SetupBlock(Trampolines.SDNSAction.Handler, action);
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend_IntPtr(base.Handle, selPerformBlock_Handle, (IntPtr)(void*)ptr);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper_IntPtr(base.SuperHandle, selPerformBlock_Handle, (IntPtr)(void*)ptr);
|
|
}
|
|
ptr->CleanupBlock();
|
|
}
|
|
|
|
[Export("performBlockAndWait:")]
|
|
public unsafe virtual void PerformAndWait(NSAction action)
|
|
{
|
|
if (action == null)
|
|
{
|
|
throw new ArgumentNullException("action");
|
|
}
|
|
BlockLiteral blockLiteral = default(BlockLiteral);
|
|
BlockLiteral* ptr = &blockLiteral;
|
|
blockLiteral.SetupBlock(Trampolines.SDNSAction.Handler, action);
|
|
if (IsDirectBinding)
|
|
{
|
|
Messaging.void_objc_msgSend_IntPtr(base.Handle, selPerformBlockAndWait_Handle, (IntPtr)(void*)ptr);
|
|
}
|
|
else
|
|
{
|
|
Messaging.void_objc_msgSendSuper_IntPtr(base.SuperHandle, selPerformBlockAndWait_Handle, (IntPtr)(void*)ptr);
|
|
}
|
|
ptr->CleanupBlock();
|
|
}
|
|
|
|
protected override void Dispose(bool disposing)
|
|
{
|
|
base.Dispose(disposing);
|
|
if (base.Handle == IntPtr.Zero)
|
|
{
|
|
__mt_PersistentStoreCoordinator_var = null;
|
|
__mt_UndoManager_var = null;
|
|
__mt_InsertedObjects_var = null;
|
|
__mt_UpdatedObjects_var = null;
|
|
__mt_DeletedObjects_var = null;
|
|
__mt_RegisteredObjects_var = null;
|
|
__mt_UserInfo_var = null;
|
|
__mt_ParentContext_var = null;
|
|
}
|
|
}
|
|
}
|
|
}
|