public static void CallCacheModificationActive(ICacheModification cacheModification, bool oldValue, bool newValue)
{
if (!oldValue)
{
cacheModification.Active = newValue;
}
}
public static void CallCacheModificationInternalUpdate(ICacheModification cacheModification, bool oldValue, bool newValue)
{
if (!oldValue)
{
cacheModification.InternalUpdate = newValue;
}
}
protected void ChangeFirstLevelCaches(CacheDependencyNode node, ISet <IObjRef> intermediateDeletes)
{
List <IDataChangeEntry> deletes = new List <IDataChangeEntry>();
ICacheModification cacheModification = this.CacheModification;
bool oldCacheModificationValue = cacheModification.Active;
if (!oldCacheModificationValue)
{
cacheModification.Active = true;
}
try
{
ChangeFirstLevelCachesIntern(node, intermediateDeletes);
}
finally
{
if (!oldCacheModificationValue)
{
cacheModification.Active = oldCacheModificationValue;
}
}
if (deletes.Count > 0)
{
IDataChange dce = DataChangeEvent.Create(0, 0, deletes.Count);
ListUtil.AddAll(dce.Deletes, dce.Deletes.Count, deletes);
GuiThreadHelper.InvokeOutOfGui(delegate()
{
EventDispatcher.DispatchEvent(dce);
});
}
}
public void FirePropertyChange(INotifyPropertyChangedSource obj, PropertyChangeSupport propertyChangeSupport, IPropertyInfo property, Object oldValue, Object currentValue)
{
ICacheModification cacheModification = this.CacheModification;
PropertyEntry entry = GetPropertyEntry(obj.GetType(), property);
if (currentValue == null)
{
currentValue = entry.getDelegate(obj);
}
try
{
if (entry.isAddedRemovedCheckNecessary)
{
if (oldValue != null)
{
HandleRemovedItem(obj, oldValue, entry.isParentChildSetter);
}
if (currentValue != null)
{
HandleAddedItem(obj, currentValue, entry.isParentChildSetter);
}
}
String[] propertyNames = entry.propertyNames;
Object[] oldValues;
Object[] currentValues;
if (FireOldPropertyValueActive)
{
oldValues = CreateArrayOfValues(oldValue, propertyNames.Length);
currentValues = Object.ReferenceEquals(currentValue, oldValue) ? oldValues : CreateArrayOfValues(currentValue, propertyNames.Length);
}
else
{
oldValues = entry.unknownValues;
currentValues = oldValues;
}
FirePropertyChange(obj, entry.pceArgs, propertyNames, oldValues, currentValues);
if (entry.firesToBeCreatedPCE)
{
IDataObject dObj = (IDataObject)obj;
if (dObj.ToBeCreated && dObj.ToBeUpdated)
{
dObj.ToBeUpdated = false;
}
}
}
finally
{
if (entry.doesModifyToBeUpdated && !cacheModification.ActiveOrFlushingOrInternalUpdate)
{
SetToBeUpdated(obj, true);
}
}
}
public void FirePropertyChange(INotifyPropertyChangedSource obj, PropertyChangedEventArgs[] evnts, String[] propertyNames, Object[] oldValues, Object[] currentValues)
{
PropertyChangeSupport propertyChangeSupport = obj.PropertyChangeSupport;
IList <IPropertyChangeExtension> extensions = propertyChangeExtensions.GetExtensions(obj.GetType());
if (propertyChangeSupport == null && extensions == null && !(obj is IPropertyChangedEventHandler))
{
return;
}
ICacheModification cacheModification = this.CacheModification;
if (cacheModification.Active)
{
cacheModification.QueuePropertyChangeEvent(delegate()
{
ExecuteFirePropertyChange(propertyChangeSupport, extensions, obj, evnts, propertyNames, oldValues, currentValues);
});
return;
}
ExecuteFirePropertyChange(propertyChangeSupport, extensions, obj, evnts, propertyNames, oldValues, currentValues);
}
public void HandleCollectionChange(INotifyPropertyChangedSource obj, Object sender, NotifyCollectionChangedEventArgs evnt)
{
IEntityMetaData metaData = ((IEntityMetaDataHolder)obj).Get__EntityMetaData();
Object bases = null;
bool parentChildProperty = false;
RelationMember[] relationMembers = metaData.RelationMembers;
for (int relationIndex = relationMembers.Length; relationIndex-- > 0;)
{
Object valueDirect = ((IValueHolderContainer)obj).Get__ValueDirect(relationIndex);
if (!Object.ReferenceEquals(valueDirect, sender))
{
continue;
}
if (relationMembers[relationIndex].GetAnnotation(typeof(ParentChild)) != null)
{
bases = obj;
parentChildProperty = true;
}
else
{
bases = sender;
}
break;
}
if (bases == null)
{
foreach (PrimitiveMember primitiveMember in metaData.PrimitiveMembers)
{
Object valueDirect = primitiveMember.GetValue(obj);
if (!Object.ReferenceEquals(valueDirect, sender))
{
continue;
}
bases = obj;
parentChildProperty = true;
break;
}
}
if (bases == null)
{
throw new Exception("Must never happen");
}
ICacheModification cacheModification = this.CacheModification;
bool oldCacheModification = cacheModification.Active;
bool cacheModificationUsed = false;
try
{
switch (evnt.Action)
{
case NotifyCollectionChangedAction.Add:
case NotifyCollectionChangedAction.Remove:
case NotifyCollectionChangedAction.Replace:
if (evnt.OldItems != null)
{
foreach (Object oldItem in evnt.OldItems)
{
HandleRemovedItem(obj, oldItem, parentChildProperty);
}
}
if (evnt.NewItems != null)
{
foreach (Object newItem in evnt.NewItems)
{
HandleAddedItem(obj, newItem, parentChildProperty);
}
}
break;
#if !SILVERLIGHT
case NotifyCollectionChangedAction.Move:
// Nothing to do in that case
break;
#endif
case NotifyCollectionChangedAction.Reset:
throw new NotSupportedException("Reset is not allowed in a managed collection");
default:
throw RuntimeExceptionUtil.CreateEnumNotSupportedException(evnt.Action);
}
IList <ICollectionChangeExtension> extensions = collectionChangeExtensions.GetExtensions(obj.GetType());
for (int a = 0, size = extensions.Count; a < size; a++)
{
extensions[a].CollectionChanged(obj, evnt);
}
}
finally
{
if (!oldCacheModification)
{
SetToBeUpdated(obj, true);
}
if (cacheModificationUsed)
{
cacheModification.Active = oldCacheModification;
}
}
}
protected void ApplyChangesToOriginalsIntern(ICUDResult cudResult, IOriCollection oriCollection, ICache cache)
{
ICacheModification cacheModification = this.CacheModification;
IConversionHelper conversionHelper = this.ConversionHelper;
IEntityMetaDataProvider entityMetaDataProvider = this.EntityMetaDataProvider;
IList <Object> originalRefs = cudResult.GetOriginalRefs();
IList <IObjRef> allChangeORIs = oriCollection.AllChangeORIs;
String[] allChangedBy = oriCollection.AllChangedBy;
long[] allChangedOn = oriCollection.AllChangedOn;
String singleChangedBy = oriCollection.ChangedBy;
long? singleChangedOn = oriCollection.ChangedOn;
bool newInstanceOnCall = CacheProvider.IsNewInstanceOnCall;
IList <Object> validObjects = new List <Object>(originalRefs.Count);
bool oldCacheModificationValue = CacheModification.Active;
CacheModification.Active = true;
try
{
for (int a = originalRefs.Count; a-- > 0;)
{
Object originalRef = originalRefs[a];
IObjRef ori = allChangeORIs[a];
if (originalRef == null)
{
// Object has been deleted by cascade delete contraints on server merge or simply a "not specified" original ref
continue;
}
if (originalRef is IObjRef)
{
continue;
}
long? changedOn = allChangedOn != null ? allChangedOn[a] : singleChangedOn;
String changedBy = allChangedBy != null ? allChangedBy[a] : singleChangedBy;
IEntityMetaData metaData = ((IEntityMetaDataHolder)originalRef).Get__EntityMetaData();
PrimitiveMember versionMember = metaData.VersionMember;
PrimitiveMember keyMember = metaData.IdMember;
PrimitiveMember onMember, byMember;
if (keyMember.GetValue(originalRef, false) == null)
{
onMember = metaData.CreatedOnMember;
byMember = metaData.CreatedByMember;
}
else
{
onMember = metaData.UpdatedOnMember;
byMember = metaData.UpdatedByMember;
}
if (onMember != null && changedOn != null)
{
Object createdOn = ConversionHelper.ConvertValueToType(onMember.ElementType, changedOn);
onMember.SetValue(originalRef, createdOn);
}
if (byMember != null && changedBy != null)
{
Object createdBy = ConversionHelper.ConvertValueToType(byMember.ElementType, changedBy);
byMember.SetValue(originalRef, createdBy);
}
if (ori == null)
{
keyMember.SetValue(originalRef, null);
if (versionMember != null)
{
versionMember.SetValue(originalRef, null);
}
if (originalRef is IDataObject)
{
((IDataObject)originalRef).ToBeUpdated = false;
((IDataObject)originalRef).ToBeDeleted = false;
}
continue; // Object has been deleted directly
}
keyMember.SetValue(originalRef, ConversionHelper.ConvertValueToType(keyMember.RealType, ori.Id));
if (versionMember != null)
{
if (AlwaysUpdateVersionInChangedEntities)
{
versionMember.SetValue(originalRef, ConversionHelper.ConvertValueToType(versionMember.RealType, ori.Version));
}
else
{
// We INTENTIONALLY do NOT set the version and let it on its old value, to force the following DCE to refresh the cached object with 'real' data
// If we set the version here to the ori.getVersion(), the DCE will 'see' a already valid object - but is IS NOT valid
// because it may not contain bi-directional information which can only be resolved by reloading the object from persistence layer
//versionMember.SetValue(originalRef, null);
}
}
if (originalRef is IDataObject)
{
((IDataObject)originalRef).ToBeUpdated = false;
((IDataObject)originalRef).ToBeDeleted = false;
}
validObjects.Add(originalRef);
}
PutInstancesToCurrentCache(validObjects, cache);
}
finally
{
CacheModification.Active = oldCacheModificationValue;
}
}
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 void Initialize(ICacheModification cacheModification, IEntityFactory entityFactory)
{
this.cacheModification = cacheModification;
this.entityFactory = entityFactory;
if (AlternateIdMemberIndicesInPrimitives == null)
{
AlternateIdMemberIndicesInPrimitives = EmptyShortArray;
}
if (PrimitiveMembers == null)
{
PrimitiveMembers = EmptyPrimitiveMembers;
}
else
{
// Array.Sort<INamed>(PrimitiveMembers, namedItemComparer);
}
List <PrimitiveMember> primitiveToManyMembers = new List <PrimitiveMember>();
foreach (PrimitiveMember primitiveMember in PrimitiveMembers)
{
if (primitiveMember.IsToMany)
{
primitiveToManyMembers.Add(primitiveMember);
}
}
this.primitiveToManyMembers = primitiveToManyMembers.ToArray();
if (RelationMembers == null)
{
RelationMembers = EmptyRelationMembers;
}
else
{
// Array.Sort<INamed>(RelationMembers, namedItemComparer);
}
if (AlternateIdMembers == null)
{
AlternateIdMembers = EmptyPrimitiveMembers;
}
else
{
// Array.Sort<INamed>(AlternateIdMembers, namedItemComparer);
}
nameToMemberDict.Clear();
relMemberToIndexDict.Clear();
relMemberNameToIndexDict.Clear();
primMemberToIndexDict.Clear();
primMemberNameToIndexDict.Clear();
if (IdMember != null)
{
PrimitiveMember idMember = IdMember;
nameToMemberDict.Add(idMember.Name, idMember);
if (idMember is CompositeIdMember)
{
foreach (PrimitiveMember member in ((CompositeIdMember)idMember).Members)
{
nameToMemberDict.Add(member.Name, member);
}
}
}
if (VersionMember != null)
{
nameToMemberDict.Add(VersionMember.Name, VersionMember);
}
for (int a = PrimitiveMembers.Length; a-- > 0;)
{
Member member = PrimitiveMembers[a];
nameToMemberDict.Add(member.Name, member);
primMemberNameToIndexDict.Add(member.Name, a);
primMemberToIndexDict.Add(member, a);
if (Object.ReferenceEquals(member, IdMember) || Object.ReferenceEquals(member, VersionMember) || Object.ReferenceEquals(member, UpdatedByMember) ||
Object.ReferenceEquals(member, UpdatedOnMember) || Object.ReferenceEquals(member, CreatedByMember) || Object.ReferenceEquals(member, CreatedOnMember))
{
// technical members must never be merge relevant
SetMergeRelevant(member, false);
}
}
for (int a = RelationMembers.Length; a-- > 0;)
{
RelationMember member = RelationMembers[a];
nameToMemberDict.Add(member.Name, member);
relMemberNameToIndexDict.Add(member.Name, a);
relMemberToIndexDict.Add(member, a);
}
memberNameToIdIndexDict.Clear();
if (IdMember != null)
{
memberNameToIdIndexDict.Add(IdMember.Name, ObjRef.PRIMARY_KEY_INDEX);
}
AlternateIdMemberIndicesInPrimitives = new int[AlternateIdMembers.Length][];
for (int idIndex = AlternateIdMembers.Length; idIndex-- > 0;)
{
int[] compositeIndex = null;
Member alternateIdMember = AlternateIdMembers[idIndex];
Member[] memberItems;
if (alternateIdMember is CompositeIdMember)
{
memberItems = ((CompositeIdMember)alternateIdMember).Members;
}
else
{
memberItems = new Member[] { alternateIdMember };
}
compositeIndex = new int[memberItems.Length];
for (int compositePosition = compositeIndex.Length; compositePosition-- > 0;)
{
compositeIndex[compositePosition] = -1;
Member memberItem = memberItems[compositePosition];
for (int primitiveIndex = PrimitiveMembers.Length; primitiveIndex-- > 0;)
{
if (memberItem.Equals(PrimitiveMembers[primitiveIndex]))
{
compositeIndex[compositePosition] = primitiveIndex;
break;
}
}
if (compositeIndex[compositePosition] == -1)
{
throw new Exception("AlternateId is not a primitive: " + memberItem);
}
}
AlternateIdMemberIndicesInPrimitives[idIndex] = compositeIndex;
memberNameToIdIndexDict.Add(alternateIdMember.Name, (sbyte)idIndex);
}
if (TypesRelatingToThis != null && TypesRelatingToThis.Length > 0)
{
for (int i = TypesRelatingToThis.Length; i-- > 0;)
{
typesRelatingToThisSet.Add(TypesRelatingToThis[i]);
}
}
if (CreatedByMember != null)
{
ChangeInterningBehavior(CreatedByMember, true);
}
if (UpdatedByMember != null)
{
ChangeInterningBehavior(UpdatedByMember, true);
}
SetTechnicalMember(IdMember);
SetTechnicalMember(VersionMember);
SetTechnicalMember(CreatedByMember);
SetTechnicalMember(CreatedOnMember);
SetTechnicalMember(UpdatedByMember);
SetTechnicalMember(UpdatedOnMember);
}
