public override void Execute(IReader reader)
{
Object value = ObjectFuture.Value;
if (typeof(IObjRef).IsAssignableFrom(Parent.GetType().GetElementType()))
{
// Happens in CUDResults in PostProcessing tags (<pp>)
value = new DirectObjRef(value.GetType(), value);
}
((Array)Parent).SetValue(value, Index);
}
public IObjRef EntityToObjRef(Object entity, int idIndex, IEntityMetaData metaData, bool forceOri)
{
Object id;
Object version;
Member versionMember = metaData.VersionMember;
if (entity is AbstractCacheValue)
{
AbstractCacheValue cacheValue = (AbstractCacheValue)entity;
if (idIndex == ObjRef.PRIMARY_KEY_INDEX)
{
id = cacheValue.Id;
}
else
{
id = CompositeIdFactory.CreateIdFromPrimitives(metaData, idIndex, cacheValue);
}
version = cacheValue.Version;
}
else if (entity is ILoadContainer)
{
ILoadContainer lc = (ILoadContainer)entity;
if (idIndex == ObjRef.PRIMARY_KEY_INDEX)
{
id = lc.Reference.Id;
}
else
{
id = CompositeIdFactory.CreateIdFromPrimitives(metaData, idIndex, lc.Primitives);
}
version = lc.Reference.Version;
}
else
{
id = metaData.GetIdMemberByIdIndex(idIndex).GetValue(entity, false);
version = versionMember != null?versionMember.GetValue(entity, false) : null;
}
IObjRef ori;
if (id != null || forceOri)
{
ori = ObjRefFactory.CreateObjRef(metaData.EntityType, idIndex, id, version);
}
else
{
ori = new DirectObjRef(metaData.EntityType, entity);
}
return(ori);
}
public IObjRef GetCreateObjRef(Object obj, MergeHandle mergeHandle)
{
if (obj == null)
{
return(null);
}
IObjRef ori = null;
IDictionary <Object, IObjRef> objToOriDict = mergeHandle != null ? mergeHandle.objToOriDict : null;
if (objToOriDict != null)
{
ori = DictionaryExtension.ValueOrDefault(objToOriDict, obj);
}
if (ori != null)
{
return(ori);
}
if (obj is IObjRef)
{
return((IObjRef)obj);
}
if (!(obj is IEntityMetaDataHolder))
{
return(null);
}
IEntityMetaData metaData = ((IEntityMetaDataHolder)obj).Get__EntityMetaData();
Object keyValue;
if (obj is AbstractCacheValue)
{
keyValue = ((AbstractCacheValue)obj).Id;
}
else
{
keyValue = metaData.IdMember.GetValue(obj, false);
}
if (keyValue == null || mergeHandle != null && mergeHandle.HandleExistingIdAsNewId)
{
IDirectObjRef dirOri = new DirectObjRef(metaData.EntityType, obj);
if (keyValue != null)
{
dirOri.Id = keyValue;
}
ori = dirOri;
}
else
{
Object version;
if (obj is AbstractCacheValue)
{
version = ((AbstractCacheValue)obj).Version;
}
else
{
Member versionMember = metaData.VersionMember;
version = versionMember != null?versionMember.GetValue(obj, true) : null;
}
ori = ObjRefFactory.CreateObjRef(metaData.EntityType, ObjRef.PRIMARY_KEY_INDEX, keyValue, version);
}
if (objToOriDict != null)
{
objToOriDict.Add(obj, ori);
IDictionary <IObjRef, Object> oriToObjDict = mergeHandle != null ? mergeHandle.oriToObjDict : null;
if (oriToObjDict != null && !oriToObjDict.ContainsKey(ori))
{
oriToObjDict.Add(ori, obj);
}
}
return(ori);
}
protected ICUDResult ApplyIntern(ICUDResult cudResult, bool checkBaseState, IncrementalMergeState incrementalState)
{
ICache stateCache = incrementalState.GetStateCache();
IList <IChangeContainer> allChanges = cudResult.AllChanges;
IList <Object> originalRefs = cudResult.GetOriginalRefs();
IList <Object> allObjects = GetAllExistingObjectsFromCache(stateCache, allChanges);
List <Object> hardRefs = new List <Object>();
hardRefs.Add(allObjects); // add list as item intended. adding each item of the source is NOT needed
List <IObjRef> toFetchFromCache = new List <IObjRef>();
List <DirectValueHolderRef> toPrefetch = new List <DirectValueHolderRef>();
List <IBackgroundWorkerDelegate> runnables = new List <IBackgroundWorkerDelegate>();
IEntityFactory entityFactory = this.EntityFactory;
IdentityHashMap <IObjRef, StateEntry> newObjRefToStateEntryMap = new IdentityHashMap <IObjRef, StateEntry>();
IdentityHashMap <IChangeContainer, IChangeContainer> alreadyClonedMap = new IdentityHashMap <IChangeContainer, IChangeContainer>();
List <IChangeContainer> newAllChanges = new List <IChangeContainer>(allChanges.Count);
for (int a = 0, size = allChanges.Count; a < size; a++)
{
IChangeContainer changeContainer = allChanges[a];
Object originalEntity = originalRefs[a];
StateEntry stateEntry = incrementalState.entityToStateMap.Get(originalEntity);
IChangeContainer newChangeContainer;
if (changeContainer is CreateContainer)
{
newChangeContainer = new CreateContainer();
}
else if (changeContainer is UpdateContainer)
{
newChangeContainer = new UpdateContainer();
}
else
{
newChangeContainer = new DeleteContainer();
}
newAllChanges.Add(newChangeContainer);
alreadyClonedMap.Put(changeContainer, newChangeContainer);
if (!(changeContainer is CreateContainer))
{
Object stateCacheEntity2 = allObjects[a];
stateEntry = incrementalState.entityToStateMap.Get(stateCacheEntity2);
if (stateEntry == null)
{
stateEntry = new StateEntry(stateCacheEntity2, changeContainer.Reference, incrementalState.entityToStateMap.Count + 1);
incrementalState.entityToStateMap.Put(stateCacheEntity2, stateEntry);
incrementalState.objRefToStateMap.Put(stateEntry.objRef, stateEntry);
}
// delete & update do not need further handling
continue;
}
Type realType = changeContainer.Reference.RealType;
Object stateCacheEntity;
if (stateEntry == null)
{
stateCacheEntity = entityFactory.CreateEntity(realType);
DirectObjRef directObjRef = new DirectObjRef(realType, stateCacheEntity);
directObjRef.CreateContainerIndex = a;
stateEntry = new StateEntry(stateCacheEntity, directObjRef, incrementalState.entityToStateMap.Count + 1);
incrementalState.entityToStateMap.Put(stateCacheEntity, stateEntry);
incrementalState.objRefToStateMap.Put(stateEntry.objRef, stateEntry);
newObjRefToStateEntryMap.Put(changeContainer.Reference, stateEntry);
}
else
{
stateCacheEntity = stateEntry.entity;
}
allObjects[a] = stateCacheEntity;
}
cloneStateTL.Value = new CloneState(newObjRefToStateEntryMap, incrementalState);
try
{
for (int a = allChanges.Count; a-- > 0;)
{
IChangeContainer changeContainer = allChanges[a];
IObjRefContainer entity = (IObjRefContainer)allObjects[a];
changeContainer = FillClonedChangeContainer(changeContainer, alreadyClonedMap);
IPrimitiveUpdateItem[] puis;
IRelationUpdateItem[] ruis;
if (changeContainer is CreateContainer)
{
CreateContainer createContainer = (CreateContainer)changeContainer;
puis = createContainer.Primitives;
ruis = createContainer.Relations;
}
else if (changeContainer is UpdateContainer)
{
UpdateContainer updateContainer = (UpdateContainer)changeContainer;
puis = updateContainer.Primitives;
ruis = updateContainer.Relations;
}
else
{
((IDataObject)entity).ToBeDeleted = true;
continue;
}
IEntityMetaData metaData = ((IEntityMetaDataHolder)entity).Get__EntityMetaData();
ApplyPrimitiveUpdateItems(entity, puis, metaData);
if (ruis != null)
{
bool isUpdate = changeContainer is UpdateContainer;
foreach (IRelationUpdateItem rui in ruis)
{
ApplyRelationUpdateItem(entity, rui, isUpdate, metaData, toPrefetch, toFetchFromCache, checkBaseState, runnables);
}
}
}
while (toPrefetch.Count > 0 || toFetchFromCache.Count > 0 || runnables.Count > 0)
{
if (toPrefetch.Count > 0)
{
PrefetchHelper.Prefetch(toPrefetch);
toPrefetch.Clear();
}
if (toFetchFromCache.Count > 0)
{
IList <Object> fetchedObjects = stateCache.GetObjects(toFetchFromCache, CacheDirective.None);
hardRefs.Add(fetchedObjects); // add list as item intended. adding each item of the source is NOT needed
toFetchFromCache.Clear();
}
IBackgroundWorkerDelegate[] runnableArray = runnables.ToArray();
runnables.Clear();
foreach (IBackgroundWorkerDelegate runnable in runnableArray)
{
runnable();
}
}
List <Object> newObjects = new List <Object>(allObjects.Count);
List <DirectValueHolderRef> changedRelationRefs = new List <DirectValueHolderRef>();
for (int a = allObjects.Count; a-- > 0;)
{
IChangeContainer newChange = newAllChanges[a];
IRelationUpdateItem[] ruis = null;
Object entity = allObjects[a];
if (newChange is CreateContainer)
{
newObjects.Add(entity);
ruis = ((CreateContainer)newChange).Relations;
}
else if (newChange is UpdateContainer)
{
ruis = ((UpdateContainer)newChange).Relations;
}
if (ruis == null)
{
continue;
}
IEntityMetaData metaData = EntityMetaDataProvider.GetMetaData(entity.GetType());
foreach (IRelationUpdateItem rui in ruis)
{
Member member = metaData.GetMemberByName(rui.MemberName);
changedRelationRefs.Add(new DirectValueHolderRef((IObjRefContainer)entity, (RelationMember)member));
}
}
if (newObjects.Count > 0)
{
((IWritableCache)stateCache).Put(newObjects);
}
if (changedRelationRefs.Count > 0)
{
PrefetchHelper.Prefetch(changedRelationRefs);
}
return(new CUDResult(newAllChanges, allObjects));
}
finally
{
cloneStateTL.Value = null;
}
}
