protected void CheckCascadeRefreshNeeded(CacheDependencyNode node)
{
CacheChangeItem[] cacheChangeItems = node.cacheChangeItems;
if (cacheChangeItems == null)
{
return;
}
HashMap <IObjRef, CacheValueAndPrivilege> objRefToCacheValueMap = node.objRefToCacheValueMap;
for (int c = cacheChangeItems.Length; c-- > 0;)
{
CacheChangeItem cci = cacheChangeItems[c];
if (cci == null)
{
continue;
}
IList <IObjRef> objectRefsToUpdate = cci.UpdatedObjRefs;
IList <Object> objectsToUpdate = cci.UpdatedObjects;
for (int a = objectRefsToUpdate.Count; a-- > 0;)
{
IObjRef objRefToUpdate = objectRefsToUpdate[a];
Object objectToUpdate = objectsToUpdate[a];
CacheValueAndPrivilege cacheValueAndPrivilege = objRefToCacheValueMap.Get(objRefToUpdate);
if (cacheValueAndPrivilege == null)
{
// Current value in childCache is not in our interest here
continue;
}
IEntityMetaData metaData = ((IEntityMetaDataHolder)objectToUpdate).Get__EntityMetaData();
RelationMember[] relationMembers = metaData.RelationMembers;
if (relationMembers.Length == 0)
{
continue;
}
RootCacheValue cacheValue = cacheValueAndPrivilege.cacheValue;
IObjRefContainer vhc = (IObjRefContainer)objectToUpdate;
for (int relationIndex = relationMembers.Length; relationIndex-- > 0;)
{
if (ValueHolderState.INIT != vhc.Get__State(relationIndex))
{
continue;
}
// the object which has to be updated has initialized relations. So we have to ensure
// that these relations are in the RootCache at the time the target object will be updated.
// This is because initialized relations have to remain initialized after update but the relations
// may have been updated, too
BatchPendingRelations(cacheValue, relationMembers[relationIndex], cacheValue.GetRelation(relationIndex), node);
}
}
}
}
protected void BatchPendingRelations(RootCacheValue cacheValue, RelationMember member, IObjRef[] relationsOfMember, CacheDependencyNode node)
{
if (relationsOfMember == null)
{
IObjRelation objRelation = ValueHolderContainerMixin.GetSelf(cacheValue, member.Name);
node.cascadeRefreshObjRelationsSet.Add(objRelation);
IObjRef[] objRefs = objRelation.ObjRefs;
for (int a = objRefs.Length; a-- > 0;)
{
objRefs[a].Version = null;
}
((ObjRelation)objRelation).Version = null;
}
else
{
node.cascadeRefreshObjRefsSet.AddAll(relationsOfMember);
}
}
protected void ChangeSecondLevelCacheIntern(CacheDependencyNode node, CacheDirective cacheDirective)
{
IRootCache rootCache = node.rootCache;
HashMap <IObjRef, CacheValueAndPrivilege> objRefToLoadContainerDict = node.objRefToCacheValueMap;
CHashSet <IObjRef> objRefsToLoad = new CHashSet <IObjRef>(node.objRefsToLoad);
if (node.cacheChangeItems != null)
{
foreach (CacheChangeItem cci in node.cacheChangeItems)
{
if (cci == null)
{
continue;
}
objRefsToLoad.AddAll(cci.UpdatedObjRefs);
}
}
IList <IObjRef> objRefs = objRefsToLoad.ToList();
IList <Object> refreshResult = rootCache.GetObjects(objRefs, cacheDirective);
IPrivilege[] privileges = null;
if (SecurityActivation != null && PrivilegeProvider != null && SecurityActivation.FilterActivated)
{
privileges = PrivilegeProvider.GetPrivilegesByObjRef(objRefs).GetPrivileges();
}
for (int a = refreshResult.Count; a-- > 0;)
{
RootCacheValue cacheValue = (RootCacheValue)refreshResult[a];
if (cacheValue == null)
{
continue;
}
objRefToLoadContainerDict.Put(objRefs[a], new CacheValueAndPrivilege(cacheValue, privileges != null ? privileges[a] : null));
}
CheckCascadeRefreshNeeded(node);
CHashSet <IObjRef> cascadeRefreshObjRefsSet = node.cascadeRefreshObjRefsSet;
CHashSet <IObjRelation> cascadeRefreshObjRelationsSet = node.cascadeRefreshObjRelationsSet;
if (cascadeRefreshObjRelationsSet.Count > 0)
{
IList <IObjRelationResult> relationsResult = rootCache.GetObjRelations(cascadeRefreshObjRelationsSet.ToList(), cacheDirective);
for (int a = relationsResult.Count; a-- > 0;)
{
IObjRelationResult relationResult = relationsResult[a];
cascadeRefreshObjRefsSet.AddAll(relationResult.Relations);
}
// apply gathered information of unknown relations to the rootCache
rootCache.Put(relationsResult);
}
if (cascadeRefreshObjRefsSet.Count > 0)
{
IList <IObjRef> cascadeRefreshObjRefsSetList = cascadeRefreshObjRefsSet.ToList();
refreshResult = rootCache.GetObjects(cascadeRefreshObjRefsSetList, cacheDirective);
}
List <CacheDependencyNode> childNodes = node.childNodes;
for (int a = childNodes.Count; a-- > 0;)
{
ChangeSecondLevelCacheIntern(childNodes[a], failInCacheHierarchyAndCacheValueResultAndReturnMissesSet);
}
}
public IndirectValueHolderRef(RootCacheValue cacheValue, RelationMember member, RootCache rootCache, bool objRefsOnly)
: base(cacheValue, member, objRefsOnly)
{
this.rootCache = rootCache;
}
public IndirectValueHolderRef(RootCacheValue cacheValue, RelationMember member, RootCache rootCache) : base(cacheValue, member)
{
this.rootCache = rootCache;
}
protected bool HandleValueHolder(DirectValueHolderRef vhr, PrefetchPath[] cachePaths, IMap <ICacheIntern, IISet <IObjRef> > cacheToOrisToLoad,
IMap <ICacheIntern, IMap <IObjRelation, bool> > cacheToOrelsToLoad, IMap <ICacheIntern, IISet <IObjRef> > cacheToOrisLoadedHistory,
IMap <ICacheIntern, IISet <IObjRelation> > cacheToOrelsLoadedHistory, AlreadyHandledSet alreadyHandledSet, IList <PrefetchCommand> cascadeLoadItems)
{
RelationMember member = vhr.Member;
bool newOriToLoad = false;
if (vhr is IndirectValueHolderRef)
{
RootCacheValue rcv = (RootCacheValue)vhr.Vhc;
ICacheIntern rootCache = ((IndirectValueHolderRef)vhr).RootCache;
IEntityMetaData metaData = EntityMetaDataProvider.GetMetaData(rcv.EntityType);
int relationIndex = metaData.GetIndexByRelation(member);
IObjRef[] rcvObjRefs = rcv.GetRelation(relationIndex);
if (rcvObjRefs == null)
{
IObjRelation self = ValueHolderContainerMixin.GetSelf(rcv, member.Name);
ISet <IObjRelation> orelsLoadedHistory = cacheToOrelsLoadedHistory.Get(rootCache);
if (orelsLoadedHistory == null || !orelsLoadedHistory.Contains(self))
{
IMap <IObjRelation, bool> orelsToLoad = cacheToOrelsToLoad.Get(rootCache);
if (orelsToLoad == null)
{
orelsToLoad = new HashMap <IObjRelation, bool>();
cacheToOrelsToLoad.Put(rootCache, orelsToLoad);
}
orelsToLoad.Put(self, vhr.ObjRefsOnly);
AddCascadeLoadItem(vhr, cachePaths, cascadeLoadItems);
}
return(false);
}
else if (!vhr.ObjRefsOnly && rcvObjRefs.Length > 0)
{
ISet <IObjRef> orisLoadedHistory = cacheToOrisLoadedHistory.Get(rootCache);
for (int b = rcvObjRefs.Length; b-- > 0;)
{
IObjRef ori = rcvObjRefs[b];
if (orisLoadedHistory != null && orisLoadedHistory.Contains(ori))
{
// Object has been tried to load before but it is obviously not in the cache
// So the load must have been failed somehow. It is assumed that the entity
// is not persisted in the database anymore (deleted before) so the ORI is illegal.
// We cleanup the ValueHolder so that future calls will not lead to
// another unnecessary roundtrip to the server
rcvObjRefs[b] = null;
continue;
}
IISet <IObjRef> orisToLoad = cacheToOrisToLoad.Get(rootCache);
if (orisToLoad == null)
{
orisToLoad = new CHashSet <IObjRef>();
cacheToOrisToLoad.Put(rootCache, orisToLoad);
}
orisToLoad.Add(ori);
newOriToLoad = true;
}
if (newOriToLoad)
{
AddCascadeLoadItem(vhr, cachePaths, cascadeLoadItems);
}
}
return(false);
}
IValueHolderContainer vhc = (IValueHolderContainer)vhr.Vhc;
int relationIndex2 = vhc.Get__EntityMetaData().GetIndexByRelationName(member.Name);
if (ValueHolderState.INIT == vhc.Get__State(relationIndex2))
{
return(true);
}
ICacheIntern cache = vhc.__TargetCache;
IObjRef[] objRefs = vhc.Get__ObjRefs(relationIndex2);
if (objRefs == null)
{
IObjRelation self = vhc.Get__Self(relationIndex2);
List <IObjRelation> orels = new List <IObjRelation>();
orels.Add(self);
IList <IObjRelationResult> orelResults = cache.GetObjRelations(orels, cache, failEarlyReturnMisses);
IObjRelationResult orelResult = orelResults[0];
if (orelResult == null)
{
ISet <IObjRelation> orelsLoadedHistory = cacheToOrelsLoadedHistory.Get(cache);
if (orelsLoadedHistory == null || !orelsLoadedHistory.Contains(self))
{
IMap <IObjRelation, bool> orelsToLoad = cacheToOrelsToLoad.Get(cache);
if (orelsToLoad == null)
{
orelsToLoad = new HashMap <IObjRelation, bool>();
cacheToOrelsToLoad.Put(cache, orelsToLoad);
}
orelsToLoad.Put(self, vhr.ObjRefsOnly);
AddCascadeLoadItem(vhr, cachePaths, cascadeLoadItems);
}
return(false);
}
objRefs = orelResult.Relations;
if (objRefs != null)
{
vhc.Set__ObjRefs(relationIndex2, objRefs);
}
}
if (!vhr.ObjRefsOnly && objRefs != null && objRefs.Length > 0)
{
IList <Object> loadedObjects = cache.GetObjects(new List <IObjRef>(objRefs), cache, failEarlyReturnMisses);
try
{
for (int b = objRefs.Length; b-- > 0;)
{
IObjRef ori = objRefs[b];
Object loadedObject = loadedObjects[b];
if (loadedObject != null)
{
continue;
}
ISet <IObjRef> orisLoadedHistory = cacheToOrisLoadedHistory.Get(cache);
if (orisLoadedHistory != null && orisLoadedHistory.Contains(ori))
{
// Object has been tried to load before but it is obviously not in the cache
// So the load must have been failed somehow. It is assumed that the entity
// is not persisted in the database anymore (deleted before) so the ORI is illegal.
// We cleanup the ValueHolder so that future calls will not lead to
// another unnecessary roundtrip to the server
objRefs[b] = null;
continue;
}
IISet <IObjRef> orisToLoad = cacheToOrisToLoad.Get(cache);
if (orisToLoad == null)
{
orisToLoad = new CHashSet <IObjRef>();
cacheToOrisToLoad.Put(cache, orisToLoad);
}
orisToLoad.Add(ori);
newOriToLoad = true;
}
}
finally
{
loadedObjects.Clear();
loadedObjects = null;
}
}
if (objRefs == null || newOriToLoad)
{
AddCascadeLoadItem(vhr, cachePaths, cascadeLoadItems);
return(false);
}
return(true);
}
public CacheValueAndPrivilege(RootCacheValue cacheValue, IPrivilege privilege)
{
this.cacheValue = cacheValue;
this.privilege = privilege;
}