protected void PostProcess(IPostProcessWriter writer)
{
ILinkedMap <String, IXmlPostProcessor> xmlPostProcessors = XmlPostProcessorRegistry.GetXmlPostProcessors();
ILinkedMap <String, Object> ppResults = new LinkedHashMap <String, Object>((int)(xmlPostProcessors.Count / 0.75 + 1));
foreach (Entry <String, IXmlPostProcessor> entry in xmlPostProcessors)
{
String tagName = entry.Key;
IXmlPostProcessor xmlPostProcessor = entry.Value;
Object result = xmlPostProcessor.ProcessWrite(writer);
if (result != null)
{
ppResults.Put(tagName, result);
}
}
if (ppResults.Count == 0)
{
return;
}
String postProcessElement = XmlDictionary.PostProcessElement;
writer.WriteStartElement(postProcessElement);
foreach (Entry <String, Object> entry in ppResults)
{
String tagName = entry.Key;
Object result = entry.Value;
writer.WriteOpenElement(tagName);
writer.WriteObject(result);
writer.WriteCloseElement(tagName);
}
writer.WriteCloseElement(postProcessElement);
}
protected bool IsPrio2Member(IEntityMetaData rootMetaData, IEntityMetaData metaData, PrefetchPath[] prefetchPaths,
ILinkedMap <Type, PrefetchPath[]> entityTypeToPrefetchSteps, Tuple2KeyHashMap <Type, PrefetchPath[], bool?> alreadyVisited,
MergePrefetchPathsCache mergePrefetchPathsCache)
{
IEntityMetaDataProvider entityMetaDataProvider = this.entityMetaDataProvider;
foreach (PrefetchPath prefetchPath in prefetchPaths)
{
if (!alreadyVisited.PutIfNotExists(prefetchPath.memberType, prefetchPath.children, true))
{
continue;
}
PrefetchPath[] children = mergePrefetchPathsCache.MergePrefetchPaths(prefetchPath.memberType, prefetchPath.children, entityTypeToPrefetchSteps);
if (children == null)
{
continue;
}
IEntityMetaData childMetaData = entityMetaDataProvider.GetMetaData(prefetchPath.memberType);
if (metaData == childMetaData)
{
// prio1 case at a later stage
continue;
}
if (rootMetaData == childMetaData)
{
// prio1 in a transitive manner (current stage)
return(true);
}
if (IsPrio2Member(rootMetaData, childMetaData, children, entityTypeToPrefetchSteps, alreadyVisited, mergePrefetchPathsCache))
{
return(true);
}
}
return(false);
}
protected void HandleObjects(Object objects, ILinkedMap <Type, PrefetchPath[]> entityTypeToPrefetchPath,
AlreadyHandledSet alreadyHandledSet, IdentityLinkedMap <ICacheIntern, IISet <IObjRef> > cacheToOrisLoadedHistory,
IdentityLinkedMap <ICacheIntern, IISet <IObjRelation> > cacheToOrelsLoadedHistory, IdentityLinkedMap <ICacheIntern, IISet <IObjRef> > cacheToOrisToLoad,
IdentityLinkedMap <ICacheIntern, IMap <IObjRelation, Boolean> > cacheToOrelsToLoad, List <PrefetchCommand> loadItems)
{
if (objects is IEnumerable && !objects.GetType().Equals(typeof(String)))
{
foreach (Object item in (IEnumerable)objects)
{
if (item == null)
{
continue;
}
HandleObjects(item, entityTypeToPrefetchPath, alreadyHandledSet, cacheToOrisLoadedHistory, cacheToOrelsLoadedHistory,
cacheToOrisToLoad, cacheToOrelsToLoad, loadItems);
}
return;
}
PrefetchPath[] cachePaths = null;
if (entityTypeToPrefetchPath != null)
{
IEntityMetaData metaData = EntityMetaDataProvider.GetMetaData(objects.GetType());
cachePaths = entityTypeToPrefetchPath.Get(metaData.EntityType);
if (cachePaths == null || cachePaths.Length == 0)
{
return;
}
}
EnsureInitializedRelationsIntern3(objects, cachePaths, entityTypeToPrefetchPath, cacheToOrisToLoad, cacheToOrelsToLoad, cacheToOrisLoadedHistory,
cacheToOrelsLoadedHistory, alreadyHandledSet, loadItems);
}
public IPrefetchState EnsureInitializedRelations(Object objects, ILinkedMap <Type, PrefetchPath[]> entityTypeToPrefetchSteps)
{
if (objects == null || entityTypeToPrefetchSteps == null || entityTypeToPrefetchSteps.Count == 0)
{
return(null);
}
return(EnsureInitializedRelationsIntern(objects, entityTypeToPrefetchSteps));
}
protected void UpdateAllEntityMetaDataWithLifecycleExtensions()
{
ILinkedMap <Type, IEntityMetaData> typeToMetaDataMap = GetExtensions();
foreach (Entry <Type, IEntityMetaData> entry in typeToMetaDataMap)
{
UpdateEntityMetaDataWithLifecycleExtensions(entry.Value);
}
}
protected IPrefetchState EnsureInitializedRelationsIntern2(Object objects, ILinkedMap <Type, PrefetchPath[]> entityTypeToPrefetchPath)
{
bool setCreated = false;
try
{
AlreadyHandledSet alreadyHandledSet = alreadyHandledSetTL.Value;
if (alreadyHandledSet == null)
{
alreadyHandledSet = new AlreadyHandledSet();
alreadyHandledSetTL.Value = alreadyHandledSet;
setCreated = true;
}
IEntityMetaDataProvider entityMetaDataProvider = this.EntityMetaDataProvider;
ValueHolderContainerMixin valueHolderContainerMixin = this.ValueHolderContainerMixin;
IdentityLinkedMap <ICacheIntern, IISet <IObjRef> > cacheToOrisLoadedHistory = new IdentityLinkedMap <ICacheIntern, IISet <IObjRef> >();
IdentityLinkedMap <ICacheIntern, IISet <IObjRelation> > cacheToOrelsLoadedHistory = new IdentityLinkedMap <ICacheIntern, IISet <IObjRelation> >();
IdentityLinkedMap <ICacheIntern, IISet <IObjRef> > cacheToOrisToLoad = new IdentityLinkedMap <ICacheIntern, IISet <IObjRef> >();
IdentityLinkedMap <ICacheIntern, IMap <IObjRelation, bool> > cacheToOrelsToLoad = new IdentityLinkedMap <ICacheIntern, IMap <IObjRelation, bool> >();
List <PrefetchCommand> loadItems = new List <PrefetchCommand>();
HandleObjects(objects, entityTypeToPrefetchPath, alreadyHandledSet, cacheToOrisLoadedHistory, cacheToOrelsLoadedHistory, cacheToOrisToLoad,
cacheToOrelsToLoad, loadItems);
// Remove all oris which have already been tried to load before
if (cacheToOrisToLoad.Count == 0 && cacheToOrelsToLoad.Count == 0)
{
// No ori remaining which makes sense to try to load
if (setCreated)
{
return(new PrefetchState(alreadyHandledSet));
}
return(null);
}
List <Object> hardRefList = new List <Object>();
// Store hard-ref-list to global hard ref
alreadyHandledSet.Put(hardRefList, null, true);
ProcessPendingOrelsAndObjRefs(entityTypeToPrefetchPath, alreadyHandledSet, cacheToOrisLoadedHistory, cacheToOrelsLoadedHistory, cacheToOrisToLoad,
cacheToOrelsToLoad, loadItems, hardRefList);
// No ori remaining which makes sense to try to load
if (setCreated)
{
return(new PrefetchState(alreadyHandledSet));
}
return(null);
}
finally
{
if (setCreated)
{
alreadyHandledSetTL.Value = null;
}
}
}
protected IPrefetchState EnsureInitializedRelationsIntern(Object objects, ILinkedMap <Type, PrefetchPath[]> entityTypeToPrefetchPaths)
{
if (objects == null)
{
return(null);
}
if (!LazyTransactionActive || Transaction == null || Transaction.Active)
{
return(EnsureInitializedRelationsIntern2(objects, entityTypeToPrefetchPaths));
}
return(Transaction.RunInLazyTransaction(delegate()
{
return EnsureInitializedRelationsIntern2(objects, entityTypeToPrefetchPaths);
}));
}
public Attribute[] GetAnnotations()
{
ILinkedMap <Type, Attribute[]> annotations = this.annotations;
if (annotations == null)
{
return(EMPTY_ANNOTATIONS);
}
List <Attribute> allAnnotations = new List <Attribute>();
foreach (Entry <Type, Attribute[]> entry in annotations)
{
allAnnotations.AddRange(entry.Value);
}
return(allAnnotations.ToArray());
}
protected virtual IList <ICommandContainer> GetOrderedCommandContainers()
{
ILinkedMap <CommandKey, ICommandContainer> containers = keyToCommandContainer.GetExtensions();
List <CommandKey> orderedKeys = new List <CommandKey>(containers.KeySet());
orderedKeys.Sort();
IList <ICommandContainer> containerList = new List <ICommandContainer>();
foreach (CommandKey commandKey in orderedKeys)
{
containerList.Add(containers.Get(commandKey));
}
// Now the result must be ordered corresponding to the command priorities:
//IOrderedEnumerable<ICommandContainer> result = containerList.OrderBy(commandContainer => (commandContainer as ICommandContainer).Priority);
return(containerList);
}
protected void LoadAndAddOrels(ILinkedMap <ICacheIntern, IMap <IObjRelation, bool> > cacheToOrelsToLoad, IList <Object> hardRefList,
IMap <ICacheIntern, IISet <IObjRelation> > cacheToOrelsLoadedHistory, ILinkedMap <ICacheIntern, IISet <IObjRef> > cacheToOrisToLoad,
IdentityLinkedSet <Member> prioMembers)
{
Iterator <Entry <ICacheIntern, IMap <IObjRelation, bool> > > iter = cacheToOrelsToLoad.Iterator();
while (iter.MoveNext())
{
Entry <ICacheIntern, IMap <IObjRelation, bool> > entry = iter.Current;
ICacheIntern cache = entry.Key;
IMap <IObjRelation, bool> orelsToLoad = entry.Value;
LoadAndAddOrels(cache, orelsToLoad, hardRefList, cacheToOrelsLoadedHistory, cacheToOrisToLoad, prioMembers);
if (orelsToLoad.Count == 0)
{
iter.Remove();
}
}
}
public void PutAnnotations(ICustomAttributeProvider obj)
{
if (obj is MethodInfo)
{
MethodInfo m = (MethodInfo)obj;
Type[] parameters = new Type[m.GetParameters().Length];
for (int a = m.GetParameters().Length; a-- > 0;)
{
parameters[a] = m.GetParameters()[a].ParameterType;
}
Type baseType = m.DeclaringType.BaseType;
MethodInfo overriddenMethod = baseType != null?ReflectUtil.GetDeclaredMethod(true, baseType, m.ReturnType, m.Name, parameters) : null;
if (overriddenMethod != null)
{
PutAnnotations(overriddenMethod);
}
}
Object[] annotations = obj.GetCustomAttributes(true);
foreach (Object anno in annotations)
{
Attribute annotation = (Attribute)anno;
AttributeUsageAttribute attributeUsage = AnnotationUtil.GetAnnotation <AttributeUsageAttribute>(annotation.GetType(), true);
Type type = annotation.GetType();
if (this.annotations == null)
{
this.annotations = new LinkedHashMap <Type, Attribute[]>();
}
Attribute[] existingAttributes = this.annotations.Get(type);
if (existingAttributes == null)
{
existingAttributes = new Attribute[0];
}
Attribute[] newAttributes = new Attribute[existingAttributes.Length + 1];
Array.Copy(existingAttributes, newAttributes, existingAttributes.Length);
newAttributes[existingAttributes.Length] = annotation;
this.annotations.Put(type, newAttributes);
}
}
protected void ProcessPendingOrelsAndObjRefs(ILinkedMap <Type, PrefetchPath[]> entityTypeToPrefetchPath,
AlreadyHandledSet alreadyHandledSet, IdentityLinkedMap <ICacheIntern, IISet <IObjRef> > cacheToOrisLoadedHistory,
IdentityLinkedMap <ICacheIntern, IISet <IObjRelation> > cacheToOrelsLoadedHistory, IdentityLinkedMap <ICacheIntern, IISet <IObjRef> > cacheToOrisToLoad,
IdentityLinkedMap <ICacheIntern, IMap <IObjRelation, bool> > cacheToOrelsToLoad, List <PrefetchCommand> pendingPrefetchCommands,
List <Object> hardRefList)
{
// all relation members where at least one instance of the owning entity type needs a prefetch on this member in the immediate next step
MergePrefetchPathsCache mergePrefetchPathsCache = new MergePrefetchPathsCache(EntityMetaDataProvider);
IdentityLinkedSet <Member> prioMembers = PrioMembersProvider.GetPrioMembers(entityTypeToPrefetchPath, pendingPrefetchCommands, mergePrefetchPathsCache);
LoadAndAddOrels(cacheToOrelsToLoad, hardRefList, cacheToOrelsLoadedHistory, cacheToOrisToLoad, prioMembers);
LoadAndAddOris(cacheToOrisToLoad, hardRefList, cacheToOrisLoadedHistory);
while (pendingPrefetchCommands.Count > 0)
{
PrefetchCommand[] currentPrefetchCommands = pendingPrefetchCommands.ToArray();
// Clear the items to be ready for cascaded items in new batch recursion step
pendingPrefetchCommands.Clear();
if (prioMembers.Count > 0)
{
for (int a = 0, size = currentPrefetchCommands.Length; a < size; a++)
{
PrefetchCommand prefetchCommand = currentPrefetchCommands[a];
DirectValueHolderRef valueHolder = prefetchCommand.valueHolder;
if (!prioMembers.Contains(valueHolder.Member))
{
currentPrefetchCommands[a] = null;
pendingPrefetchCommands.Add(prefetchCommand);
}
}
}
GuiThreadHelper.InvokeInGuiAndWait(delegate()
{
ICacheModification cacheModification = CacheModification;
ValueHolderContainerMixin valueHolderContainerMixin = ValueHolderContainerMixin;
bool oldActive = cacheModification.Active;
if (!oldActive)
{
cacheModification.Active = true;
}
try
{
foreach (PrefetchCommand prefetchCommand in currentPrefetchCommands)
{
if (prefetchCommand == null)
{
continue;
}
DirectValueHolderRef valueHolder = prefetchCommand.valueHolder;
PrefetchPath[] cachePaths = prefetchCommand.prefetchPaths;
RelationMember member = valueHolder.Member;
// Merge the root prefetch path with the relative prefetch path
cachePaths = mergePrefetchPathsCache.MergePrefetchPaths(member.ElementType, cachePaths, entityTypeToPrefetchPath);
IObjRefContainer vhc = valueHolder.Vhc;
ICacheIntern targetCache;
bool doSetValue = false;
if (valueHolder is IndirectValueHolderRef)
{
IndirectValueHolderRef valueHolderKey = (IndirectValueHolderRef)valueHolder;
targetCache = valueHolderKey.RootCache;
}
else
{
targetCache = ((IValueHolderContainer)vhc).__TargetCache;
doSetValue = true;
}
int relationIndex = vhc.Get__EntityMetaData().GetIndexByRelation(member);
IObjRef[] objRefs = vhc.Get__ObjRefs(relationIndex);
Object obj = valueHolderContainerMixin.GetValue(vhc, relationIndex, member, targetCache, objRefs, CacheDirective.FailEarly);
if (doSetValue && obj != null)
{
member.SetValue(vhc, obj);
}
EnsureInitializedRelationsIntern3(obj, cachePaths, entityTypeToPrefetchPath, cacheToOrisToLoad, cacheToOrelsToLoad, cacheToOrisLoadedHistory,
cacheToOrelsLoadedHistory, alreadyHandledSet, pendingPrefetchCommands);
}
}
finally
{
if (!oldActive)
{
cacheModification.Active = false;
}
}
});
// Remove all oris which have already been tried to load before
if (cacheToOrisToLoad.Count == 0 && cacheToOrelsToLoad.Count == 0 && pendingPrefetchCommands.Count == 0)
{
return;
}
prioMembers = PrioMembersProvider.GetPrioMembers(entityTypeToPrefetchPath, pendingPrefetchCommands, mergePrefetchPathsCache);
LoadAndAddOrels(cacheToOrelsToLoad, hardRefList, cacheToOrelsLoadedHistory, cacheToOrisToLoad, prioMembers);
LoadAndAddOris(cacheToOrisToLoad, hardRefList, cacheToOrisLoadedHistory);
}
}
public IdentityLinkedSet <Member> GetPrioMembers(ILinkedMap <Type, PrefetchPath[]> entityTypeToPrefetchPath,
List <PrefetchCommand> pendingPrefetchCommands, MergePrefetchPathsCache mergePrefetchPathsCache)
{
IdentityLinkedSet <Member> key1 = new IdentityLinkedSet <Member>();
PrioMembersKey key = new PrioMembersKey(entityTypeToPrefetchPath, key1);
for (int a = 0, size = pendingPrefetchCommands.Count; a < size; a++)
{
PrefetchCommand prefetchCommand = pendingPrefetchCommands[a];
key1.Add(prefetchCommand.valueHolder.Member);
}
IdentityLinkedSet <Member> prioMembersMap = activeMembersToPrioMembersMap.Get(key);
if (prioMembersMap != null)
{
return(prioMembersMap);
}
prioMembersMap = new IdentityLinkedSet <Member>(0.5f);
Tuple2KeyHashMap <Type, PrefetchPath[], bool?> alreadyVisited = null;
IdentityHashSet <Type> touchedTypesInPriority = null;
if (mergePrefetchPathsCache == null)
{
mergePrefetchPathsCache = new MergePrefetchPathsCache(entityMetaDataProvider);
}
bool prio2Mode = true;
foreach (PrefetchCommand prefetchCommand in pendingPrefetchCommands)
{
DirectValueHolderRef valueHolder = prefetchCommand.valueHolder;
PrefetchPath[] prefetchPaths = prefetchCommand.prefetchPaths;
RelationMember member = valueHolder.Member;
Type targetEntityType = member.ElementType;
// Merge the root prefetch path with the relative prefetch path
prefetchPaths = mergePrefetchPathsCache.MergePrefetchPaths(targetEntityType, prefetchPaths, entityTypeToPrefetchPath);
IEntityMetaData metaData = valueHolder.Vhc.Get__EntityMetaData();
if (targetEntityType.Equals(metaData.EntityType))
{
// prio1 overrides prio2
if (prio2Mode)
{
prio2Mode = false;
alreadyVisited = null;
prioMembersMap.Clear();
if (touchedTypesInPriority != null)
{
touchedTypesInPriority.Clear();
}
}
prioMembersMap.Add(member);
if (touchedTypesInPriority == null)
{
touchedTypesInPriority = new IdentityHashSet <Type>();
}
touchedTypesInPriority.Add(member.EntityType);
touchedTypesInPriority.Add(targetEntityType);
continue;
}
if (prefetchPaths == null || !prio2Mode)
{
continue;
}
if (alreadyVisited == null)
{
alreadyVisited = new Tuple2KeyHashMap <Type, PrefetchPath[], bool?>();
}
if (IsPrio2Member(metaData, entityMetaDataProvider.GetMetaData(targetEntityType), prefetchPaths, entityTypeToPrefetchPath, alreadyVisited,
mergePrefetchPathsCache))
{
prioMembersMap.Add(member);
if (touchedTypesInPriority == null)
{
touchedTypesInPriority = new IdentityHashSet <Type>();
}
touchedTypesInPriority.Add(member.EntityType);
touchedTypesInPriority.Add(targetEntityType);
}
}
if (prioMembersMap.Count > 0)
{
// check for out-of-order members which have nothing to do (and will never ever have in a transitive manner) with the priorized members
foreach (PrefetchCommand prefetchCommand in pendingPrefetchCommands)
{
DirectValueHolderRef valueHolder = prefetchCommand.valueHolder;
RelationMember member = valueHolder.Member;
if (prioMembersMap.Contains(member))
{
// already priorized
continue;
}
if (touchedTypesInPriority.Contains(member.EntityType) || touchedTypesInPriority.Contains(member.ElementType))
{
continue;
}
prioMembersMap.Add(member);
}
}
Object writeLock = activeMembersToPrioMembersMap.GetWriteLock();
lock (writeLock)
{
IdentityLinkedSet <Member> existingPrioMembersMap = activeMembersToPrioMembersMap.Get(key);
if (existingPrioMembersMap != null)
{
return(existingPrioMembersMap);
}
activeMembersToPrioMembersMap.Put(key, prioMembersMap);
return(prioMembersMap);
}
}
public ICUDResult CreateCUDResult(MergeHandle mergeHandle)
{
ILinkedMap <Type, ICUDResultExtension> typeToCudResultExtension = extensions.GetExtensions();
foreach (Entry <Type, ICUDResultExtension> entry in typeToCudResultExtension)
{
entry.Value.Extend(mergeHandle);
}
IdentityLinkedMap <Object, IList <IUpdateItem> > objToModDict = mergeHandle.objToModDict;
IdentityHashSet <Object> objToDeleteSet = mergeHandle.objToDeleteSet;
HashMap <Type, IPrimitiveUpdateItem[]> entityTypeToFullPuis = new HashMap <Type, IPrimitiveUpdateItem[]>();
HashMap <Type, IRelationUpdateItem[]> entityTypeToFullRuis = new HashMap <Type, IRelationUpdateItem[]>();
List <IChangeContainer> allChanges = new List <IChangeContainer>(objToModDict.Count);
List <Object> originalRefs = new List <Object>(objToModDict.Count);
foreach (Object objToDelete in objToDeleteSet)
{
IObjRef ori = OriHelper.GetCreateObjRef(objToDelete, mergeHandle);
DeleteContainer deleteContainer = new DeleteContainer();
deleteContainer.Reference = ori;
allChanges.Add(deleteContainer);
originalRefs.Add(objToDelete);
}
IEntityMetaDataProvider entityMetaDataProvider = this.EntityMetaDataProvider;
foreach (Entry <Object, IList <IUpdateItem> > entry in objToModDict)
{
Object obj = entry.Key;
IList <IUpdateItem> modItems = entry.Value;
IEntityMetaData metaData = entityMetaDataProvider.GetMetaData(obj.GetType());
IPrimitiveUpdateItem[] fullPuis = GetEnsureFullPUIs(metaData, entityTypeToFullPuis);
IRelationUpdateItem[] fullRuis = GetEnsureFullRUIs(metaData, entityTypeToFullRuis);
int puiCount = 0, ruiCount = 0;
for (int a = modItems.Count; a-- > 0;)
{
IUpdateItem modItem = modItems[a];
Member member = metaData.GetMemberByName(modItem.MemberName);
if (modItem is IRelationUpdateItem)
{
fullRuis[metaData.GetIndexByRelation(member)] = (IRelationUpdateItem)modItem;
ruiCount++;
}
else
{
fullPuis[metaData.GetIndexByPrimitive(member)] = (IPrimitiveUpdateItem)modItem;
puiCount++;
}
}
IRelationUpdateItem[] ruis = CompactRUIs(fullRuis, ruiCount);
IPrimitiveUpdateItem[] puis = CompactPUIs(fullPuis, puiCount);
IObjRef ori = OriHelper.GetCreateObjRef(obj, mergeHandle);
originalRefs.Add(obj);
if (ori is IDirectObjRef)
{
CreateContainer createContainer = new CreateContainer();
((IDirectObjRef)ori).CreateContainerIndex = allChanges.Count;
createContainer.Reference = ori;
createContainer.Primitives = puis;
createContainer.Relations = ruis;
allChanges.Add(createContainer);
}
else
{
UpdateContainer updateContainer = new UpdateContainer();
updateContainer.Reference = ori;
updateContainer.Primitives = puis;
updateContainer.Relations = ruis;
allChanges.Add(updateContainer);
}
}
return(new CUDResult(allChanges, originalRefs));
}
public PrioMembersKey(ILinkedMap <Type, PrefetchPath[]> referent, IdentityLinkedSet <Member> key1) : base(referent)
{
this.key1 = key1;
}
protected IList <IEntityMetaData> GetMetaData(IList <Type> entityTypes, bool askRemoteOnMiss)
{
List <IEntityMetaData> result = new List <IEntityMetaData>(entityTypes.Count);
IList <Type> missingEntityTypes = null;
for (int a = entityTypes.Count; a-- > 0;)
{
Type entityType = entityTypes[a];
IEntityMetaData metaDataItem = GetExtension(entityType);
if (Object.ReferenceEquals(metaDataItem, alreadyHandled))
{
metaDataItem = GetExtensionHardKey(entityType);
if (metaDataItem == null && askRemoteOnMiss)
{
if (missingEntityTypes == null)
{
missingEntityTypes = new List <Type>();
}
missingEntityTypes.Add(entityType);
}
continue;
}
if (metaDataItem == null)
{
if (askRemoteOnMiss)
{
if (missingEntityTypes == null)
{
missingEntityTypes = new List <Type>();
}
missingEntityTypes.Add(entityType);
}
continue;
}
result.Add(metaDataItem);
}
if (missingEntityTypes == null || RemoteEntityMetaDataProvider == null)
{
return(result);
}
bool handlePendingMetaData = false;
try
{
ClassExtendableContainer <IEntityMetaData> pendingToRefreshMetaDatas = pendingToRefreshMetaDatasTL.Value;
if (pendingToRefreshMetaDatas == null)
{
pendingToRefreshMetaDatas = new ClassExtendableContainer <IEntityMetaData>("metaData", "entityType");
pendingToRefreshMetaDatasTL.Value = pendingToRefreshMetaDatas;
handlePendingMetaData = true;
}
while (missingEntityTypes != null && missingEntityTypes.Count > 0)
{
IList <IEntityMetaData> loadedMetaData = RemoteEntityMetaDataProvider.GetMetaData(missingEntityTypes);
IList <Type> cascadeMissingEntityTypes = AddLoadedMetaData(missingEntityTypes, loadedMetaData);
if (cascadeMissingEntityTypes != null && cascadeMissingEntityTypes.Count > 0)
{
missingEntityTypes = cascadeMissingEntityTypes;
}
else
{
missingEntityTypes.Clear();
}
}
if (handlePendingMetaData)
{
ILinkedMap <Type, IEntityMetaData> extensions = pendingToRefreshMetaDatas.GetExtensions();
foreach (Entry <Type, IEntityMetaData> entry in extensions)
{
IEntityMetaData metaData = entry.Value;
if (Object.ReferenceEquals(metaData, alreadyHandled))
{
continue;
}
RefreshMembers(metaData);
}
Object writeLock = GetWriteLock();
lock (writeLock)
{
foreach (Entry <Type, IEntityMetaData> entry in pendingToRefreshMetaDatas.GetExtensions())
{
Type entityType = entry.Key;
IEntityMetaData existingMetaData = GetExtensionHardKeyGlobalOnly(entityType);
if (existingMetaData != null && !Object.ReferenceEquals(existingMetaData, alreadyHandled))
{
// existing entry is already a valid non-null entry
continue;
}
IEntityMetaData ownMetaData = entry.Value;
if (Object.ReferenceEquals(existingMetaData, ownMetaData))
{
// existing entry is already a null-entry and our entry is a null-entry, too - so nothing to do
continue;
}
if (Object.ReferenceEquals(existingMetaData, alreadyHandled))
{
Unregister(alreadyHandled, entityType);
}
Register(ownMetaData, entityType);
}
}
}
}
finally
{
if (handlePendingMetaData)
{
pendingToRefreshMetaDatasTL.Value = null;
}
}
return(GetMetaData(entityTypes, false));
}
protected void EnsureInitializedRelationsIntern3(Object obj, PrefetchPath[] cachePaths, ILinkedMap <Type, PrefetchPath[]> entityTypeToPrefetchPaths,
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)
{
if (obj == null)
{
return;
}
if (!alreadyHandledSet.PutIfNotExists(obj, cachePaths, true))
{
return;
}
if (obj is IndirectValueHolderRef)
{
IndirectValueHolderRef vhk = (IndirectValueHolderRef)obj;
HandleValueHolder(vhk, cachePaths, cacheToOrisToLoad, cacheToOrelsToLoad, cacheToOrisLoadedHistory, cacheToOrelsLoadedHistory,
alreadyHandledSet, cascadeLoadItems);
// Do nothing because this is only to prefetch RootCache entries
return;
}
else if (obj is DirectValueHolderRef)
{
DirectValueHolderRef vhk = (DirectValueHolderRef)obj;
if (!HandleValueHolder(vhk, cachePaths, cacheToOrisToLoad, cacheToOrelsToLoad, cacheToOrisLoadedHistory, cacheToOrelsLoadedHistory,
alreadyHandledSet, cascadeLoadItems))
{
return;
}
// force valueholder init. at this point we know that all related items are already in the cache. there will be no roundtrip
// to the server
if (vhk.Member == null)
{
obj = vhk.Vhc;
}
else
{
obj = vhk.Member.GetValue(vhk.Vhc);
}
}
if (obj == null)
{
// this check is necessary because even if we create only instances of DirectValueHolderRef in cases where there is a not initalized relation
// even then it might be possible that a concurrent thread initializes the valueholder to null (e.g. an empty to-one relation)
return;
}
if ((cachePaths == null || cachePaths.Length == 0) && entityTypeToPrefetchPaths == null)
{
return;
}
if (obj is IEnumerable)
{
var items = new List <Object>();
foreach (Object item in (IEnumerable)obj)
{
if (item == null)
{
continue;
}
items.Add(item);
}
foreach (Object item in items)
{
EnsureInitializedRelationsIntern3(item, cachePaths, entityTypeToPrefetchPaths, cacheToOrisToLoad, cacheToOrelsToLoad,
cacheToOrisLoadedHistory, cacheToOrelsLoadedHistory, alreadyHandledSet, cascadeLoadItems);
}
return;
}
IEntityMetaData metaData = ((IEntityMetaDataHolder)obj).Get__EntityMetaData();
if (cachePaths == null || cachePaths.Length == 0)
{
if (entityTypeToPrefetchPaths != null)
{
cachePaths = entityTypeToPrefetchPaths.Get(metaData.EntityType);
}
if (cachePaths == null || cachePaths.Length == 0)
{
return;
}
}
RelationMember[] relationMembers = metaData.RelationMembers;
if (relationMembers.Length == 0)
{
return;
}
IValueHolderContainer vhc = (IValueHolderContainer)obj;
for (int a = cachePaths.Length; a-- > 0;)
{
PrefetchPath path = cachePaths[a];
int relationIndex = path.memberIndex;
RelationMember member = relationMembers[relationIndex];
if (ValueHolderState.INIT != vhc.Get__State(relationIndex))
{
DirectValueHolderRef vhk = new DirectValueHolderRef(vhc, member);
EnsureInitializedRelationsIntern3(vhk, path.children, entityTypeToPrefetchPaths, cacheToOrisToLoad, cacheToOrelsToLoad, cacheToOrisLoadedHistory,
cacheToOrelsLoadedHistory, alreadyHandledSet, cascadeLoadItems);
continue;
}
Object memberValue = member.GetValue(obj);
if (memberValue == null)
{
continue;
}
EnsureInitializedRelationsIntern3(memberValue, path.children, entityTypeToPrefetchPaths, cacheToOrisToLoad, cacheToOrelsToLoad,
cacheToOrisLoadedHistory, cacheToOrelsLoadedHistory, alreadyHandledSet, cascadeLoadItems);
}
}
protected void LoadAndAddOrels(ICacheIntern cache, IMap <IObjRelation, bool> orelsToLoad, IList <Object> hardRefList,
IMap <ICacheIntern, IISet <IObjRelation> > cacheToOrelsLoadedHistory, ILinkedMap <ICacheIntern, IISet <IObjRef> > cacheToOrisToLoad,
IdentityLinkedSet <Member> prioMembers)
{
IList <IObjRelation> objRelList;
if (prioMembers.Count > 0)
{
objRelList = new List <IObjRelation>(orelsToLoad.Count);
IEntityMetaDataProvider entityMetaDataProvider = this.EntityMetaDataProvider;
foreach (Entry <IObjRelation, Boolean> entry in orelsToLoad)
{
IObjRelation objRel = entry.Key;
IEntityMetaData metaData = entityMetaDataProvider.GetMetaData(objRel.RealType);
RelationMember memberByName = (RelationMember)metaData.GetMemberByName(objRel.MemberName);
if (!prioMembers.Contains(memberByName))
{
continue;
}
objRelList.Add(objRel);
}
}
else
{
objRelList = orelsToLoad.KeyList();
}
IList <IObjRelationResult> objRelResults = cache.GetObjRelations(objRelList, cache, CacheDirective.ReturnMisses);
IISet <IObjRef> orisToLoad = null;
for (int a = 0, size = objRelResults.Count; a < size; a++)
{
IObjRelation objRel = objRelList[a];
IObjRelationResult objRelResult = objRelResults[a];
bool objRefsOnly = orelsToLoad.Remove(objRel);
if (objRelResult == null)
{
continue;
}
if (orelsToLoad.Get(objRel))
{
// fetch only the objRefs, not the objects themselves
continue;
}
IObjRef[] relations = objRelResult.Relations;
if (relations.Length == 0 || objRefsOnly)
{
// fetch only the objRefs, not the objects themselves
continue;
}
if (orisToLoad == null)
{
orisToLoad = cacheToOrisToLoad.Get(cache);
if (orisToLoad == null)
{
orisToLoad = new CHashSet <IObjRef>();
cacheToOrisToLoad.Put(cache, orisToLoad);
}
}
orisToLoad.AddAll(relations);
}
IISet <IObjRelation> orelsLoadedHistory = cacheToOrelsLoadedHistory.Get(cache);
if (orelsLoadedHistory == null)
{
orelsLoadedHistory = new CHashSet <IObjRelation>();
cacheToOrelsLoadedHistory.Put(cache, orelsLoadedHistory);
}
orelsLoadedHistory.AddAll(objRelList);
}
public PrefetchHandle(ILinkedMap <Type, PrefetchPath[]> entityTypeToPrefetchSteps, ICachePathHelper cachePathHelper)
{
this.entityTypeToPrefetchSteps = entityTypeToPrefetchSteps;
this.cachePathHelper = cachePathHelper;
}
