protected override Object InterceptDeleteIntern(MethodInfo method, Object[] arguments, Attribute annotation,
Boolean?isAsyncBegin)
{
if (arguments == null || (arguments.Length != 1 && arguments.Length != 3))
{
throw new Exception("Arguments currently must be only 1 or 3: " + method.ToString());
}
ProceedWithMergeHook proceedHook = GetProceedHook(arguments);
MergeFinishedCallback finishedCallback = GetFinishedCallback(arguments);
RemoveAttribute remove = (RemoveAttribute)annotation;
if (remove != null)
{
String idName = remove.IdName;
Type entityType = remove.EntityType;
if (idName != null && idName.Length > 0)
{
if (entityType == null)
{
throw new Exception("Annotation invalid: " + remove + " on method " + method.ToString());
}
DeleteById(method, entityType, idName, arguments[0], proceedHook, finishedCallback);
return(null);
}
}
Object argumentToDelete = arguments[0];
MergeProcess.Process(null, argumentToDelete, proceedHook, finishedCallback);
if (!typeof(void).Equals(method.ReturnType))
{
return(argumentToDelete);
}
return(null);
}
protected void DeleteById(MethodInfo method, Type entityType, String idName, Object ids, ProceedWithMergeHook proceedHook, MergeFinishedCallback finishedCallback)
{
IEntityMetaData metaData = GetSpecifiedMetaData(method, typeof(RemoveAttribute), entityType);
Member idMember = GetSpecifiedMember(method, typeof(RemoveAttribute), metaData, idName);
sbyte idIndex = metaData.GetIdIndexByMemberName(idName);
Type idType = idMember.RealType;
List <IObjRef> objRefs = new List <IObjRef>();
BuildObjRefs(entityType, idIndex, idType, ids, objRefs);
MergeProcess.Process(null, objRefs, proceedHook, finishedCallback);
}
public void Test_DataChange()
{
TestEntity newTestEntity = EntityFactory.CreateEntity <TestEntity>();
CountDownLatch latch = new CountDownLatch(1);
MergeProcess.Process(newTestEntity, null, null, delegate(bool success)
{
latch.CountDown();
});
latch.Await();
WaitForUI();
newTestEntity.Relation = EntityFactory.CreateEntity <TestEntity2>();
ICacheWalkerResult cwResult = CacheWalker.WalkEntities(newTestEntity);
Log.Info(cwResult.ToString());
ICUDResult mergeResult = MergeController.MergeDeep(newTestEntity, new MergeHandle());
latch = new CountDownLatch(1);
RevertChangesHelper.RevertChanges(newTestEntity, delegate(bool success)
{
latch.CountDown();
});
latch.Await();
WaitForUI();
((IWritableCache)Cache).Put(newTestEntity);
latch = new CountDownLatch(1);
((INotifyPropertyChanged)newTestEntity).PropertyChanged += delegate(Object sender, PropertyChangedEventArgs evnt)
{
latch.CountDown();
};
MergeService.Merge(mergeResult, null);
latch.Await();
WaitForUI();
Assert.AssertNotNull(newTestEntity.Relation);
}
protected override Object InterceptMergeIntern(MethodInfo method, Object[] arguments, Attribute annotation,
Boolean?isAsyncBegin)
{
if (arguments == null || (arguments.Length != 1 && arguments.Length != 2 && arguments.Length != 3))
{
throw new Exception("Arguments currently must be only 1, 2 or 3: " + method.ToString());
}
Object argumentToMerge = arguments[0];
Object argumentToDelete = GetArgumentToDelete(arguments, method.GetParameters());
ProceedWithMergeHook proceedHook = GetProceedHook(arguments);
MergeFinishedCallback finishedCallback = GetFinishedCallback(arguments);
MergeProcess.Process(argumentToMerge, argumentToDelete, proceedHook, finishedCallback);
if (!typeof(void).Equals(method.ReturnType))
{
return(argumentToMerge);
}
return(null);
}
public IProcess Create(string process)
{
IProcess currentProcess;
switch (process.ToUpper())
{
case "INSERT":
currentProcess = new InsertionProcess();
break;
case "MERGE":
currentProcess = new MergeProcess();
break;
default:
throw new NotImplementedException();
}
return(currentProcess);
}
protected IOriCollection MergeIntern(ICUDResult cudResultOriginal, IMethodDescription methodDescription)
{
IResultingBackgroundWorkerDelegate <IOriCollection> runnable = new IResultingBackgroundWorkerDelegate <IOriCollection>(delegate()
{
IDisposableCache childCache = CacheFactory.CreatePrivileged(CacheFactoryDirective.SubscribeTransactionalDCE, false, false,
"MergeServiceRegistry.STATE");
try
{
IncrementalMergeState state = null;
ICUDResult cudResultOfCache;
if (MergeProcess.IsAddNewlyPersistedEntities() || (Log.DebugEnabled && CudResultPrinter != null))
{
childCache = CacheFactory.CreatePrivileged(CacheFactoryDirective.SubscribeTransactionalDCE, false, false,
"MergeServiceRegistry.STATE");
state = (IncrementalMergeState)CudResultApplier.AcquireNewState(childCache);
cudResultOfCache = CudResultApplier.ApplyCUDResultOnEntitiesOfCache(cudResultOriginal, true, state);
}
else
{
cudResultOfCache = cudResultOriginal;
}
if (Log.DebugEnabled)
{
if (CudResultPrinter != null)
{
Log.Debug("Initial merge [" + RuntimeHelpers.GetHashCode(state) + "]:\n" + CudResultPrinter.PrintCUDResult(cudResultOfCache, state));
}
else
{
Log.Debug("Initial merge [" + RuntimeHelpers.GetHashCode(state) + "]. No Details available");
}
}
List <MergeOperation> mergeOperationSequence = new List <MergeOperation>();
ICUDResult extendedCudResult = WhatIfMerged(cudResultOfCache, methodDescription, mergeOperationSequence, state);
if (Log.DebugEnabled)
{
Log.Debug("Merge finished [" + RuntimeHelpers.GetHashCode(state) + "]");
}
if (MergeSecurityManager != null)
{
SecurityActive.ExecuteWithSecurityDirective(SecurityDirective.ENABLE_ENTITY_CHECK, delegate()
{
MergeSecurityManager.CheckMergeAccess(extendedCudResult, methodDescription);
});
}
List <Object> originalRefsOfCache = new List <Object>(cudResultOfCache.GetOriginalRefs());
List <Object> originalRefsExtended = new List <Object>(extendedCudResult.GetOriginalRefs());
IOriCollection oriCollExtended = Intern(extendedCudResult, methodDescription, mergeOperationSequence, state);
IList <IChangeContainer> allChangesOriginal = cudResultOriginal.AllChanges;
IList <IObjRef> allChangedObjRefsExtended = oriCollExtended.AllChangeORIs;
IObjRef[] allChangedObjRefsResult = new IObjRef[allChangesOriginal.Count];
IdentityHashMap <Object, int?> originalRefOfCacheToIndexMap = new IdentityHashMap <Object, int?>();
for (int a = originalRefsOfCache.Count; a-- > 0;)
{
originalRefOfCacheToIndexMap.Put(originalRefsOfCache[a], a);
}
for (int a = originalRefsExtended.Count; a-- > 0;)
{
int?indexOfCache = originalRefOfCacheToIndexMap.Get(originalRefsExtended[a]);
if (indexOfCache == null)
{
// this is a change implied by a rule or an persistence-implicit change
// we do not know about it in the outer original CUDResult
continue;
}
IObjRef objRefExtended = allChangedObjRefsExtended[a];
IObjRef objRefOriginal = allChangesOriginal[indexOfCache.Value].Reference;
if (objRefExtended == null)
{
// entity has been deleted
objRefOriginal.Id = null;
objRefOriginal.Version = null;
}
else
{
objRefOriginal.Id = objRefExtended.Id;
objRefOriginal.Version = objRefExtended.Version;
}
if (objRefOriginal is IDirectObjRef)
{
((IDirectObjRef)objRefOriginal).Direct = null;
}
allChangedObjRefsResult[indexOfCache.Value] = objRefOriginal;
}
OriCollection oriCollection = new OriCollection(new List <IObjRef>(allChangedObjRefsResult));
return(oriCollection);
}
finally
{
childCache.Dispose();
}
});
if (SecurityActive == null || !SecurityActive.FilterActivated)
{
return(runnable());
}
else
{
return(SecurityActive.ExecuteWithoutFiltering(runnable));
}
}
