protected IdentityHashSet <Object> BuildCollisionSet(CacheDependencyNode node) { IdentityHashSet <Object> collisionSet = new IdentityHashSet <Object>(); BuildCollisionSetIntern(node, collisionSet); return(collisionSet); }
public IList <T> GetObjects <T>() { CheckNotDisposed(); IdentityHashSet <T> result = new IdentityHashSet <T>(); IList <T> parentResult = parent != null?parent.GetObjects <T>() : null; if (parentResult != null) { foreach (T parentItem in parentResult) { result.Add(parentItem); } } readLock.Lock(); try { HandleObjects(delegate(Object obj) { if (typeof(T).IsAssignableFrom(obj.GetType())) { result.Add((T)obj); } }); return(ListUtil.ToList(result)); } finally { readLock.Unlock(); } }
protected void Initialize() { HashMap <Type, IISet <Type> > typeRelatedByTypes = new HashMap <Type, IISet <Type> >(); IdentityHashSet <IEntityMetaData> extensions = new IdentityHashSet <IEntityMetaData>(GetExtensions().Values()); foreach (IEntityMetaData metaData in extensions) { if (Object.ReferenceEquals(metaData, alreadyHandled)) { continue; } foreach (RelationMember relationMember in metaData.RelationMembers) { AddTypeRelatedByTypes(typeRelatedByTypes, metaData.EntityType, relationMember.ElementType); } } foreach (IEntityMetaData metaData in extensions) { if (Object.ReferenceEquals(metaData, alreadyHandled)) { continue; } Type entityType = metaData.EntityType; IISet <Type> relatedByTypes = typeRelatedByTypes.Get(entityType); if (relatedByTypes == null) { relatedByTypes = new CHashSet <Type>(); } ((EntityMetaData)metaData).TypesRelatingToThis = relatedByTypes.ToArray(); RefreshMembers(metaData); } }
public virtual void DisplayCurrentSortStates() { GridViewColumnCollection columns = GridViewDataControl.Columns; ISet <GridViewBoundColumnBase> unmatchedColumns = new IdentityHashSet <GridViewBoundColumnBase>(); foreach (GridViewBoundColumnBase column in columns) { unmatchedColumns.Add(column); } foreach (AmbethSortDescriptor sortDescriptor in SortDescriptorList) { foreach (GridViewBoundColumnBase column in columns) { if (column.GetDataMemberName() == sortDescriptor.Member) { column.SortingState = SortDescriptorConverter.GetTelerikSortingState(sortDescriptor); unmatchedColumns.Remove(column); break; } } } foreach (GridViewBoundColumnBase unmatchedColumn in unmatchedColumns) { unmatchedColumn.SortingState = SortingState.None; } }
public virtual void RemoveArgument(ExtractionObject argToRemove, bool removeParent) { ICollection <ExtractionObject> thisEvent = new IdentityHashSet <ExtractionObject>(); thisEvent.Add(argToRemove); RemoveArguments(thisEvent, removeParent); }
public override void Execute(Object parameter, INextCommandDelegate commandFinishedCallback) { if (RevertChangesSavepoint == null) { base.Execute(parameter, commandFinishedCallback); return; } if (parameter == null) { if (commandFinishedCallback != null) { commandFinishedCallback.Invoke(true); } return; } IList <Object> businessObjects = ExtractBusinessObjects(parameter); RevertChangesFinishedCallback revertChangesFinishedCallback = null; if (commandFinishedCallback != null) { revertChangesFinishedCallback = new RevertChangesFinishedCallback(delegate(bool success) { commandFinishedCallback.Invoke(success); }); } IdentityHashSet <Object> mentionedBusinessObjects = new IdentityHashSet <Object>(businessObjects); IdentityHashSet <Object> savepointBusinessObjects = new IdentityHashSet <Object>(RevertChangesSavepoint.GetSavedBusinessObjects()); mentionedBusinessObjects.RemoveAll(savepointBusinessObjects); RevertChangesSavepoint.RevertChanges(); RevertChangesHelper.RevertChanges(mentionedBusinessObjects, revertChangesFinishedCallback); }
public IList <Object> ScanForInitializedObjects(Object obj, bool isDeepMerge, IMap <Type, IList <Object> > typeToObjectsToMerge, IList <IObjRef> objRefs, IList <ValueHolderRef> valueHolderKeys) { IList <Object> objects = new List <Object>(); ISet <Object> alreadyHandledObjectsSet = new IdentityHashSet <Object>(); ScanForInitializedObjectsIntern(obj, isDeepMerge, objects, typeToObjectsToMerge, alreadyHandledObjectsSet, objRefs, valueHolderKeys); return(objects); }
public DefaultExtendableContainer(String message) { this.type = typeof(V); this.message = message; set = new IdentityHashSet <V>(); ReadWriteLock rwLock = new ReadWriteLock(); readLock = rwLock.ReadLock; writeLock = rwLock.WriteLock; }
protected ICacheWalkerResult WalkIntern(IObjRef[] objRefs, IdentityHashSet <ICache> allCachesSet) { IdentityHashMap <ICache, List <ICache> > cacheToChildCaches = new IdentityHashMap <ICache, List <ICache> >(); IdentityHashMap <ICache, ICache> cacheToProxyCache = new IdentityHashMap <ICache, ICache>(); ICache currentCommittedRootCache = CommittedRootCache.CurrentCache; if (!CacheProvider.IsNewInstanceOnCall) { allCachesSet.Add(FirstLevelCache.CurrentCache); } ICache[] allChildCaches = allCachesSet.ToArray(); allCachesSet.Add(currentCommittedRootCache); foreach (ICache childCache in allChildCaches) { ICache child = childCache; ICache parent = ((ChildCache)child).Parent; while (parent != null) { ICache currentParent = parent.CurrentCache; if (!allCachesSet.Add(currentParent)) { // skip this cache. we handled it already break; } CheckParentCache(parent, currentParent, child, cacheToChildCaches, cacheToProxyCache); parent = ((IRootCache)currentParent).Parent; child = currentParent; } CheckParentCache(CommittedRootCache, currentCommittedRootCache, child, cacheToChildCaches, cacheToProxyCache); } if (objRefs != allEntityRefs) { objRefs = new CHashSet <IObjRef>(objRefs).ToArray(); Array.Sort(objRefs, ObjRef.comparator); } CacheWalkerResult rootEntry = BuildWalkedEntry(currentCommittedRootCache, objRefs, cacheToChildCaches, cacheToProxyCache); if (objRefs == allEntityRefs) { HashMap <IObjRef, int?> allObjRefs = new HashMap <IObjRef, int?>(); CollectAllObjRefs(rootEntry, allObjRefs); objRefs = allObjRefs.Count > 0 ? ListUtil.ToArray(allObjRefs.KeyList()) : ObjRef.EMPTY_ARRAY; Array.Sort(objRefs, ObjRef.comparator); for (int a = objRefs.Length; a-- > 0;) { allObjRefs.Put(objRefs[a], a); } ReallocateObjRefsAndCacheValues(rootEntry, objRefs, allObjRefs); } return(rootEntry); }
protected void CheckEnhancedTypeConsistency(Type type) { IdentityHashSet <MethodInfo> allMethods = new IdentityHashSet <MethodInfo>(); foreach (Type interf in type.GetInterfaces()) { allMethods.AddAll(interf.GetMethods()); } Type currType = type; while (currType != typeof(Object) && currType != null) { allMethods.AddAll(currType.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly)); currType = currType.BaseType; } if (allMethods.Count == 0) { throw new Exception("Type invalid (not a single method): " + type); } if (type.GetConstructors(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly).Length == 0) { throw new Exception("Type invalid (not a single constructor): " + type); } if (!type.IsAbstract) { foreach (MethodInfo method in allMethods) { MethodInfo method2 = ReflectUtil.GetDeclaredMethod(true, type, method.ReturnType, method.Name, TypeUtil.GetParameterTypesToTypes(method.GetParameters())); if (method2 == null || method2.IsAbstract) { throw new Exception("Type is not abstract but has at least one abstract method: " + method); } } } Type[] interfaces = type.GetInterfaces(); foreach (Type interf in interfaces) { MethodInfo[] interfaceMethods = ReflectUtil.GetDeclaredMethods(interf); foreach (MethodInfo interfaceMethod in interfaceMethods) { try { if (type.GetMethod(interfaceMethod.Name, TypeUtil.GetParameterTypesToTypes(interfaceMethod.GetParameters())) == null) { throw new Exception("Type is not abstract but has at least one abstract method: " + interfaceMethod); } } catch (Exception e) { throw new Exception("Type is not abstract but has at least one abstract method: " + interfaceMethod, e); } } } }
protected void BuildCollisionSetIntern(CacheDependencyNode node, IdentityHashSet <Object> collisionSet) { collisionSet.Add(node.rootCache); List <CacheDependencyNode> childNodes = node.childNodes; for (int a = childNodes.Count; a-- > 0;) { BuildCollisionSetIntern(childNodes[a], collisionSet); } collisionSet.AddAll(node.directChildCaches); }
protected virtual IList <Object> ExtractBusinessObjects(Object parameter, bool extractAlsoUnchanged = false) { if (parameter == null) { return(EMPTY_BO_ARRAY); } List <Object> targetObjects = new List <Object>(); IdentityHashSet <Object> alreadyScannedSet = new IdentityHashSet <Object>(); ExtractBusinessObjectsIntern(parameter, targetObjects, alreadyScannedSet, extractAlsoUnchanged); return(targetObjects); }
protected void WaitEventToResume(IBackgroundWorkerParamDelegate <IProcessResumeItem> resumeDelegate, IBackgroundWorkerParamDelegate <Exception> errorDelegate) { IRootCache rootCache = RootCache; IList <IWritableCache> selectedFirstLevelCaches = FirstLevelCacheManager.SelectFirstLevelCaches(); ISet <Object> collisionSet = new IdentityHashSet <Object>(); collisionSet.Add(rootCache); for (int a = selectedFirstLevelCaches.Count; a-- > 0;) { collisionSet.Add(selectedFirstLevelCaches[a]); } // Without the current rootcache we can not handle the event now. We have to block till the rootCache and all childCaches get valid EventDispatcher.WaitEventToResume(collisionSet, -1, resumeDelegate, errorDelegate); }
/** * Create a disjoint set for the element passed in. This method should be * called for all elements before any of the other API methods are called * (i.e. construct a disjoint set for each element first and then union them * together as appropriate). * * @param element * the element for which a new disjoint set should be * constructed. */ public void makeSet(E element) { if (!elementToSet.ContainsKey(element)) { // Note: It is necessary to use an identity based hash set // whose equal and hashCode method are based on the Sets // identity and not its elements as we are adding // this set to a set but changing its values as unions // occur. ISet <E> set = new IdentityHashSet <E>(); set.Add(element); elementToSet.Put(element, set); disjointSets.Add(set); } }
protected void DataChanged(IDataChange dataChange, Object eventTarget, IList <Object> pausedEventTargets, DateTime dispatchTime, long sequenceId) { CacheDependencyNode rootNode = BuildCacheDependency(); if (pausedEventTargets != null && pausedEventTargets.Count > 0) { IdentityHashSet <Object> collisionSet = BuildCollisionSet(rootNode); if (collisionSet.ContainsAny(pausedEventTargets)) { // Without the current rootcache we can not handle the event now. We have to block till the rootCache and all childCaches get valid EventDispatcher.WaitEventToResume(collisionSet, -1, delegate(IProcessResumeItem processResumeItem) { DataChangedIntern(dataChange, pausedEventTargets, processResumeItem, rootNode); }, null); return; } } DataChangedIntern(dataChange, pausedEventTargets, null, rootNode); }
protected void FilterWrongRelationMappings(IISet <RelationMember> relationMembers) { // filter all relations which can not be a relation because of explicit embedded property mapping IdentityHashSet <RelationMember> toRemove = new IdentityHashSet <RelationMember>(); foreach (RelationMember relationMember in relationMembers) { String[] memberPath = EmbeddedMember.Split(relationMember.Name); foreach (RelationMember otherRelationMember in relationMembers) { if (Object.ReferenceEquals(relationMember, otherRelationMember) || toRemove.Contains(otherRelationMember)) { continue; } if (!(otherRelationMember is IEmbeddedMember)) { // only embedded members can help identifying other wrong relation members continue; } String[] otherMemberPath = ((IEmbeddedMember)otherRelationMember).GetMemberPathToken(); if (memberPath.Length > otherMemberPath.Length) { continue; } bool match = true; for (int a = 0, size = memberPath.Length; a < size; a++) { if (!memberPath[a].Equals(otherMemberPath[a])) { match = false; break; } } if (match) { toRemove.Add(relationMember); break; } } } relationMembers.RemoveAll(toRemove); }
protected void HandleObjects(HandleObjectsDelegate handleObjectsDelegate) { IdentityHashSet <Object> alreadyHandledSet = new IdentityHashSet <Object>(); foreach (Entry <Type, Object> entry in typeToServiceDict) { Object obj = entry.Value; if (alreadyHandledSet.Add(obj)) { handleObjectsDelegate.Invoke(obj); } } foreach (Entry <String, Object> entry in nameToServiceDict) { Object obj = entry.Value; if (alreadyHandledSet.Add(obj)) { handleObjectsDelegate.Invoke(obj); } } }
public IList <T> GetImplementingObjects <T>() { IdentityHashSet <T> set = new IdentityHashSet <T>(); Lock readLock = this.readLock; readLock.Lock(); try { HandleObjects(delegate(Object obj) { if (typeof(T).IsAssignableFrom(obj.GetType())) { set.Add((T)obj); } }); return(ListUtil.ToList(set)); } finally { readLock.Unlock(); } }
public ICacheWalkerResult WalkEntities <T>(params T[] entities) { IList <IObjRef> objRefs = new List <IObjRef>(entities.Length); objRefs = ObjRefHelper.ExtractObjRefList(entities, null, objRefs); IdentityHashSet <ICache> allCachesSet = new IdentityHashSet <ICache>(); foreach (Object entity in entities) { if (entity is IValueHolderContainer) { ICache targetCache = ((IValueHolderContainer)entity).__TargetCache; if (targetCache != null) { allCachesSet.Add(targetCache); } } } return(WalkIntern(ListUtil.ToArray(objRefs), allCachesSet)); }
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); } }
/* * Non-recursive version of object descend. this consumes more memory than recursive in-depth * traversal but prevents stack overflows on long chains of objects * or complex graphs (a max. recursion depth on my machine was ~5000 objects linked in a chain * so not too much). */ private static long MeasureObjectSize(object root) { // Objects seen so far. IdentityHashSet <object> seen = new IdentityHashSet <object>(); // Class cache with reference Field and precalculated shallow size. IDictionary <Type, ClassCache> classCache = new JCG.Dictionary <Type, ClassCache>(IdentityEqualityComparer <Type> .Default); // Stack of objects pending traversal. Recursion caused stack overflows. Stack <object> stack = new Stack <object>(); stack.Push(root); long totalSize = 0; while (stack.Count > 0) { object ob = stack.Pop(); if (ob is null || seen.Contains(ob)) { continue; } seen.Add(ob); Type obClazz = ob.GetType(); // LUCENENET specific - .NET cannot return a null type for an object, so no need to assert it if (obClazz.Equals(typeof(string))) { // LUCENENET specific - we can get a closer estimate of a string // by using simple math. Reference: http://stackoverflow.com/a/8171099. // This fixes the TestSanity test. totalSize += (2 * (((string)ob).Length + 1)); } if (obClazz.IsArray) { /* * Consider an array, possibly of primitive types. Push any of its references to * the processing stack and accumulate this array's shallow size. */ long size = NUM_BYTES_ARRAY_HEADER; Array array = (Array)ob; int len = array.Length; if (len > 0) { Type componentClazz = obClazz.GetElementType(); if (componentClazz.IsPrimitive) { size += (long)len * primitiveSizes[componentClazz]; } else { size += (long)NUM_BYTES_OBJECT_REF * len; // Push refs for traversal later. for (int i = len; --i >= 0;) { object o = array.GetValue(i); if (o != null && !seen.Contains(o)) { stack.Push(o); } } } } totalSize += AlignObjectSize(size); } else { /* * Consider an object. Push any references it has to the processing stack * and accumulate this object's shallow size. */ try { if (!classCache.TryGetValue(obClazz, out ClassCache cachedInfo) || cachedInfo is null) { classCache[obClazz] = cachedInfo = CreateCacheEntry(obClazz); } foreach (FieldInfo f in cachedInfo.ReferenceFields) { // Fast path to eliminate redundancies. object o = f.GetValue(ob); if (o != null && !seen.Contains(o)) { stack.Push(o); } } totalSize += cachedInfo.AlignedShallowInstanceSize; } catch (Exception e) when(e.IsIllegalAccessException()) { // this should never happen as we enabled setAccessible(). throw RuntimeException.Create("Reflective field access failed?", e); } } } // Help the GC (?). seen.Clear(); stack.Clear(); classCache.Clear(); return(totalSize); }
public IteratorAnonymousClass(IdentityHashSet <KType> outerInstance) { this.outerInstance = outerInstance; pos = -1; nextElement = FetchNext(); }
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 override int GetHashCode() { IdentityHashSet<ICoreMap> calledSet = HashCodeCalled.Value; bool createdCalledSet = (calledSet == null); if (createdCalledSet) { calledSet = new IdentityHashSet<ICoreMap>(); HashCodeCalled.Value = calledSet; } if (calledSet.Contains(this)) { return 0; } calledSet.Add(this); int keysCode = 0; int valuesCode = 0; for (int i = 0; i < psize; i++) { keysCode += (i < keys.Length && values[i] != null ? keys[i].GetHashCode() : 0); valuesCode += (i < values.Length && values[i] != null ? values[i].GetHashCode() : 0); } if (createdCalledSet) { HashCodeCalled.Value = null; } else { // Remove the object after processing is complete so that if // there are multiple instances of this CoreMap in the overall // object graph, they each have their hash code calculated. // TODO: can we cache this for later? calledSet.Remove(this); } return keysCode*37 + valuesCode; }
public override string ToString() { IdentityHashSet<ICoreMap> calledSet = ToStringCalled.Value; if (calledSet == null) { calledSet = new IdentityHashSet<ICoreMap>(); } if (calledSet.Contains(this)) { return "[...]"; } calledSet.Add(this); var s = new StringBuilder("["); for (int i = 0; i < psize; i++) { s.Append(keys[i].Name); s.Append('='); s.Append(values[i]); if (i < psize - 1) { s.Append(' '); } } s.Append(']'); bool createdCalledSet = calledSet == null || calledSet.IsEmpty(); if (createdCalledSet) { ToStringCalled.Dispose(); /*remove();*/ } else { // Remove the object from the already called set so that // potential later calls in this object graph have something // more description than [...] calledSet.Remove(this); } return s.ToString(); }
static TestRandomChains() { try { brokenConstructors[typeof(LimitTokenCountFilter).GetConstructor(new Type[] { typeof(TokenStream), typeof(int) })] = ALWAYS; brokenConstructors[typeof(LimitTokenCountFilter).GetConstructor(new Type[] { typeof(TokenStream), typeof(int), typeof(bool) })] = new PredicateAnonymousInnerClassHelper2(); brokenConstructors[typeof(LimitTokenPositionFilter).GetConstructor(new Type[] { typeof(TokenStream), typeof(int) })] = ALWAYS; brokenConstructors[typeof(LimitTokenPositionFilter).GetConstructor(new Type[] { typeof(TokenStream), typeof(int), typeof(bool) })] = new PredicateAnonymousInnerClassHelper3(); foreach (Type c in Arrays.AsList( // TODO: can we promote some of these to be only // offsets offenders? // doesn't actual reset itself: typeof(CachingTokenFilter), // Not broken, simulates brokenness: typeof(CrankyTokenFilter), // Not broken: we forcefully add this, so we shouldn't // also randomly pick it: typeof(ValidatingTokenFilter))) { foreach (ConstructorInfo ctor in c.GetConstructors()) { brokenConstructors[ctor] = ALWAYS; } } } catch (Exception e) { throw new Exception(e.Message, e); } try { foreach (Type c in Arrays.AsList( typeof(ReversePathHierarchyTokenizer), typeof(PathHierarchyTokenizer), // TODO: it seems to mess up offsets!? typeof(WikipediaTokenizer), // TODO: doesn't handle graph inputs typeof(CJKBigramFilter), // TODO: doesn't handle graph inputs (or even look at positionIncrement) typeof(HyphenatedWordsFilter), // TODO: LUCENE-4983 typeof(CommonGramsFilter), // TODO: doesn't handle graph inputs typeof(CommonGramsQueryFilter), // TODO: probably doesnt handle graph inputs, too afraid to try typeof(WordDelimiterFilter))) { foreach (ConstructorInfo ctor in c.GetConstructors()) { brokenOffsetsConstructors[ctor] = ALWAYS; } } } catch (Exception e) { throw new Exception(e.Message, e); } allowedTokenizerArgs = new IdentityHashSet <Type>(); // Collections.NewSetFromMap(new IdentityHashMap<Type, bool?>()); allowedTokenizerArgs.addAll(argProducers.Keys); allowedTokenizerArgs.Add(typeof(TextReader)); allowedTokenizerArgs.Add(typeof(AttributeSource.AttributeFactory)); allowedTokenizerArgs.Add(typeof(AttributeSource)); allowedTokenFilterArgs = new IdentityHashSet <Type>(); //Collections.newSetFromMap(new IdentityHashMap<Type, bool?>()); allowedTokenFilterArgs.addAll(argProducers.Keys); allowedTokenFilterArgs.Add(typeof(TokenStream)); // TODO: fix this one, thats broken: allowedTokenFilterArgs.Add(typeof(CommonGramsFilter)); allowedCharFilterArgs = new IdentityHashSet <Type>(); //Collections.newSetFromMap(new IdentityHashMap<Type, bool?>()); allowedCharFilterArgs.addAll(argProducers.Keys); allowedCharFilterArgs.Add(typeof(TextReader)); }
public virtual Object PostProcessBean(IBeanContextFactory beanContextFactory, IServiceContext beanContext, IBeanConfiguration beanConfiguration, Type beanType, Object targetBean, ISet <Type> requestedTypes) { if (!typeof(FrameworkElement).IsAssignableFrom(beanType)) { // Handle only FrameworkElements return(targetBean); } if (beanType.IsAssignableFrom(typeof(UserControl))) { // Ignore all instances which are base types of UserControl return(targetBean); } ISet <Object> alreadyHandledBeans = factoryToAlreadyHandledNames[beanContextFactory]; if (alreadyHandledBeans == null) { alreadyHandledBeans = new IdentityHashSet <Object>(); factoryToAlreadyHandledNames[beanContextFactory] = alreadyHandledBeans; } if (alreadyHandledBeans.Contains(targetBean)) { //Do not yet add the Bean to the list. return(targetBean); } FrameworkElement frameworkElement = (FrameworkElement)targetBean; MethodInfo initializeComponentMethod = beanType.GetMethod("InitializeComponent"); if (initializeComponentMethod != null) { IServiceContext oldCurrentBeanContext = XamlBeanProvider.CurrentBeanContext; try { XamlBeanProvider.CurrentBeanContext = beanContext; initializeComponentMethod.Invoke(targetBean, null); } catch (Exception e) { throw new Exception("InitializeComponent of \"" + frameworkElement.Name + "\" (" + beanType.FullName + ") failed.", e); } finally { XamlBeanProvider.CurrentBeanContext = oldCurrentBeanContext; } } if (!typeof(UIElement).IsAssignableFrom(beanType)) { return(targetBean); } ISet <Object> unnamedBeans = new IdentityHashSet <Object>(); IDictionary <String, Object> namedBeans = new Dictionary <String, Object>(); CollectChildBeans((UIElement)targetBean, unnamedBeans, namedBeans, alreadyHandledBeans); foreach (Object unnamedBean in unnamedBeans) { IBeanConfiguration nestedBeanConfiguration = beanContextFactory.RegisterWithLifecycle(unnamedBean); if (unnamedBean is ISelfRegisteringControlBean) { ((ISelfRegisteringControlBean)unnamedBean).RegisterSelf(nestedBeanConfiguration, beanContext, beanContextFactory); } } foreach (KeyValuePair <String, Object> namedBean in namedBeans) { Object currentNamedBean = namedBean.Value; IBeanConfiguration nestedBeanConfiguration = beanContextFactory.RegisterWithLifecycle(namedBean.Key, currentNamedBean); if (currentNamedBean is ISelfRegisteringControlBean) { ((ISelfRegisteringControlBean)currentNamedBean).RegisterSelf(nestedBeanConfiguration, beanContext, beanContextFactory); } } if (targetBean is ISelfRegisteringControlBean) { ((ISelfRegisteringControlBean)targetBean).RegisterSelf(beanConfiguration, beanContext, beanContextFactory); } return(targetBean); }
public void AddMembers(EntityMetaData metaData, IEntityConfig entityConfig) { Type realType = entityConfig.RealType; ISet <String> memberNamesToIgnore = new HashSet <String>(); ISet <String> explicitBasicMemberNames = new HashSet <String>(); IList <IMemberConfig> embeddedMembers = new List <IMemberConfig>(); IMap <String, IMemberConfig> nameToMemberConfig = new HashMap <String, IMemberConfig>(); IMap <String, IRelationConfig> nameToRelationConfig = new HashMap <String, IRelationConfig>(); IdentityLinkedMap <String, Member> nameToMemberMap = new IdentityLinkedMap <String, Member>(); FillNameCollections(entityConfig, memberNamesToIgnore, explicitBasicMemberNames, embeddedMembers, nameToMemberConfig, nameToRelationConfig); IdentityLinkedSet <PrimitiveMember> alternateIdMembers = new IdentityLinkedSet <PrimitiveMember>(); IdentityLinkedSet <PrimitiveMember> primitiveMembers = new IdentityLinkedSet <PrimitiveMember>(); IdentityLinkedSet <RelationMember> relationMembers = new IdentityLinkedSet <RelationMember>(); IdentityLinkedSet <Member> notMergeRelevant = new IdentityLinkedSet <Member>(); IdentityLinkedSet <Member> containedInAlternateIdMember = new IdentityLinkedSet <Member>(); IPropertyInfo[] properties = PropertyInfoProvider.GetProperties(realType); IdentityLinkedMap <String, Member> explicitlyConfiguredMemberNameToMember = new IdentityLinkedMap <String, Member>(); HashMap <String, IOrmConfig> nameToConfigMap = new HashMap <String, IOrmConfig>(); // Resolve members for all explicit configurations - both simple and composite ones, each with embedded // functionality (dot-member-path) foreach (IMemberConfig memberConfig in entityConfig.GetMemberConfigIterable()) { PutNameToConfigMap(memberConfig, nameToConfigMap); if (memberConfig.Ignore) { continue; } HandleMemberConfig(metaData, realType, memberConfig, explicitlyConfiguredMemberNameToMember, nameToMemberMap); } foreach (IRelationConfig relationConfig in entityConfig.GetRelationConfigIterable()) { PutNameToConfigMap(relationConfig, nameToConfigMap); HandleRelationConfig(realType, relationConfig, explicitlyConfiguredMemberNameToMember); } PutNameToConfigMap(entityConfig.IdMemberConfig, nameToConfigMap); PutNameToConfigMap(entityConfig.VersionMemberConfig, nameToConfigMap); PutNameToConfigMap(entityConfig.CreatedByMemberConfig, nameToConfigMap); PutNameToConfigMap(entityConfig.CreatedOnMemberConfig, nameToConfigMap); PutNameToConfigMap(entityConfig.UpdatedByMemberConfig, nameToConfigMap); PutNameToConfigMap(entityConfig.UpdatedOnMemberConfig, nameToConfigMap); metaData.IdMember = HandleMemberConfig(metaData, realType, entityConfig.IdMemberConfig, explicitlyConfiguredMemberNameToMember, nameToMemberMap); metaData.VersionMember = HandleMemberConfig(metaData, realType, entityConfig.VersionMemberConfig, explicitlyConfiguredMemberNameToMember, nameToMemberMap); metaData.CreatedByMember = HandleMemberConfig(metaData, realType, entityConfig.CreatedByMemberConfig, explicitlyConfiguredMemberNameToMember, nameToMemberMap); metaData.CreatedOnMember = HandleMemberConfig(metaData, realType, entityConfig.CreatedOnMemberConfig, explicitlyConfiguredMemberNameToMember, nameToMemberMap); metaData.UpdatedByMember = HandleMemberConfig(metaData, realType, entityConfig.UpdatedByMemberConfig, explicitlyConfiguredMemberNameToMember, nameToMemberMap); metaData.UpdatedOnMember = HandleMemberConfig(metaData, realType, entityConfig.UpdatedOnMemberConfig, explicitlyConfiguredMemberNameToMember, nameToMemberMap); IdentityHashSet <Member> idMembers = new IdentityHashSet <Member>(); Member idMember = metaData.IdMember; if (idMember is CompositeIdMember) { idMembers.AddAll(((CompositeIdMember)idMember).Members); } else { idMembers.Add(idMember); } // Handle all explicitly configured members foreach (Entry <String, Member> entry in explicitlyConfiguredMemberNameToMember) { String memberName = entry.Key; IOrmConfig ormConfig = nameToConfigMap.Get(memberName); Member member = entry.Value; if (idMembers.Contains(member)) { continue; } if (ormConfig.ExplicitlyNotMergeRelevant) { notMergeRelevant.Add(member); } if (ormConfig is IRelationConfig) { if (!relationMembers.Add((RelationMember)member)) { throw new Exception("Member has been registered as relation multiple times: " + member.Name); } continue; } if (!(ormConfig is IMemberConfig)) { continue; } if (((IMemberConfig)ormConfig).AlternateId) { if (!alternateIdMembers.Add((PrimitiveMember)member)) { throw new Exception("Member has been registered as alternate id multiple times: " + member.Name); } if (member is CompositeIdMember) { Member[] containedMembers = ((CompositeIdMember)member).Members; containedInAlternateIdMember.AddAll(containedMembers); } } if (!(member is CompositeIdMember) && metaData.VersionMember != member) { // Alternate Ids are normally primitives, too. But Composite Alternate Ids not - only their composite // items are primitives primitiveMembers.Add((PrimitiveMember)member); } } IdentityHashSet <String> explicitTypeInfoItems = IdentityHashSet <String> .Create(explicitlyConfiguredMemberNameToMember.Count); foreach (Entry <String, Member> entry in explicitlyConfiguredMemberNameToMember) { Member member = entry.Value; explicitTypeInfoItems.Add(member.Name); if (member is IEmbeddedMember) { explicitTypeInfoItems.Add(((IEmbeddedMember)member).GetMemberPath()[0].Name); } } // Go through the available members to look for potential auto-mapping (simple, no embedded) for (int i = 0; i < properties.Length; i++) { IPropertyInfo property = properties[i]; String memberName = property.Name; if (memberNamesToIgnore.Contains(memberName)) { continue; } if (explicitTypeInfoItems.Contains(memberName)) { // already configured, no auto mapping needed for this member continue; } MethodPropertyInfo mProperty = (MethodPropertyInfo)property; Type elementType = TypeInfoItemUtil.GetElementTypeUsingReflection(mProperty.Getter.ReturnType, null); if ((nameToMemberMap.Get(property.Name) is RelationMember) || RelationProvider.IsEntityType(elementType)) { RelationMember member = GetRelationMember(metaData.EntityType, property, nameToMemberMap); relationMembers.Add(member); continue; } PrimitiveMember member2 = GetPrimitiveMember(metaData.EntityType, property, nameToMemberMap); if (metaData.IdMember == null && memberName.Equals(EntityMetaData.DEFAULT_NAME_ID)) { metaData.IdMember = member2; continue; } if (idMembers.Contains(member2) && !alternateIdMembers.Contains(member2) && !containedInAlternateIdMember.Contains(member2)) { continue; } if (member2.Equals(metaData.IdMember) || member2.Equals(metaData.VersionMember) || member2.Equals(metaData.CreatedByMember) || member2.Equals(metaData.CreatedOnMember) || member2.Equals(metaData.UpdatedByMember) || member2.Equals(metaData.UpdatedOnMember)) { continue; } if (metaData.VersionMember == null && memberName.Equals(EntityMetaData.DEFAULT_NAME_VERSION)) { metaData.VersionMember = member2; continue; } if (metaData.CreatedByMember == null && memberName.Equals(EntityMetaData.DEFAULT_NAME_CREATED_BY)) { metaData.CreatedByMember = member2; } else if (metaData.CreatedOnMember == null && memberName.Equals(EntityMetaData.DEFAULT_NAME_CREATED_ON)) { metaData.CreatedOnMember = member2; } else if (metaData.UpdatedByMember == null && memberName.Equals(EntityMetaData.DEFAULT_NAME_UPDATED_BY)) { metaData.UpdatedByMember = member2; } else if (metaData.UpdatedOnMember == null && memberName.Equals(EntityMetaData.DEFAULT_NAME_UPDATED_ON)) { metaData.UpdatedOnMember = member2; } primitiveMembers.Add(member2); } foreach (PrimitiveMember member in primitiveMembers) { String memberName = member.Name; if (explicitBasicMemberNames.Contains(memberName)) { // Even if the name would match, this member was explicitly configured as "basic" continue; } if (metaData.CreatedByMember == null && memberName.Equals(EntityMetaData.DEFAULT_NAME_CREATED_BY)) { metaData.CreatedByMember = member; } else if (metaData.CreatedOnMember == null && memberName.Equals(EntityMetaData.DEFAULT_NAME_CREATED_ON)) { metaData.CreatedOnMember = member; } else if (metaData.UpdatedByMember == null && memberName.Equals(EntityMetaData.DEFAULT_NAME_UPDATED_BY)) { metaData.UpdatedByMember = member; } else if (metaData.UpdatedOnMember == null && memberName.Equals(EntityMetaData.DEFAULT_NAME_UPDATED_ON)) { metaData.UpdatedOnMember = member; } } FilterWrongRelationMappings(relationMembers); // Order of setter calls is important PrimitiveMember[] primitives = primitiveMembers.ToArray(); PrimitiveMember[] alternateIds = alternateIdMembers.ToArray(); RelationMember[] relations = relationMembers.ToArray(); Array.Sort(primitives); Array.Sort(alternateIds); Array.Sort(relations); metaData.PrimitiveMembers = primitives; metaData.AlternateIdMembers = alternateIds; metaData.RelationMembers = relations; foreach (Member member in notMergeRelevant) { metaData.SetMergeRelevant(member, false); } if (metaData.IdMember == null) { throw new Exception("No ID member could be resolved for entity of type " + metaData.RealType); } }
public WaitForResumeItem(IdentityHashSet <Object> pendingPauses) { this.pendingPauses = pendingPauses; }
/* * Non-recursive version of object descend. this consumes more memory than recursive in-depth * traversal but prevents stack overflows on long chains of objects * or complex graphs (a max. recursion depth on my machine was ~5000 objects linked in a chain * so not too much). */ private static long MeasureObjectSize(object root) { // Objects seen so far. IdentityHashSet <object> seen = new IdentityHashSet <object>(); // Class cache with reference Field and precalculated shallow size. HashMap <Type, ClassCache> classCache = new HashMap <Type, ClassCache>(); // Stack of objects pending traversal. Recursion caused stack overflows. Stack <object> stack = new Stack <object>(); stack.Push(root); long totalSize = 0; while (stack.Count > 0) { object ob = stack.Pop(); if (ob == null || seen.Contains(ob)) { continue; } seen.Add(ob); Type obClazz = ob.GetType(); if (obClazz.IsArray) { /* * Consider an array, possibly of primitive types. Push any of its references to * the processing stack and accumulate this array's shallow size. */ long size = NUM_BYTES_ARRAY_HEADER; Array array = (Array)ob; int len = array.Length; if (len > 0) { Type componentClazz = obClazz.GetElementType(); if (componentClazz.IsPrimitive) { size += (long)len * PrimitiveSizes[componentClazz]; } else { size += (long)NUM_BYTES_OBJECT_REF * len; // Push refs for traversal later. for (int i = len; --i >= 0;) { object o = array.GetValue(i); if (o != null && !seen.Contains(o)) { stack.Push(o); } } } } totalSize += AlignObjectSize(size); } else { /* * Consider an object. Push any references it has to the processing stack * and accumulate this object's shallow size. */ try { ClassCache cachedInfo = classCache[obClazz]; if (cachedInfo == null) { classCache[obClazz] = cachedInfo = CreateCacheEntry(obClazz); } foreach (FieldInfo f in cachedInfo.ReferenceFields) { // Fast path to eliminate redundancies. object o = f.GetValue(ob); if (o != null && !seen.Contains(o)) { stack.Push(o); } } totalSize += cachedInfo.AlignedShallowInstanceSize; } catch (Exception e) { // this should never happen as we enabled setAccessible(). throw new Exception("Reflective field access failed?", e); } } } // Help the GC (?). seen.Clear(); stack.Clear(); classCache.Clear(); return(totalSize); }
protected virtual void RevertChangesIntern(IRevertChangesSavepoint savepoint, IList <Object> objectsToRevert, bool globally, RevertChangesFinishedCallback revertChangesFinishedCallback) { // Store the RevertChangesFinishedCallback from this thread on the stack and set the property null (for following calls): if (objectsToRevert == null || objectsToRevert.Count == 0) { if (revertChangesFinishedCallback != null) { revertChangesFinishedCallback.Invoke(true); } return; } if (globally) { GuiThreadHelper.InvokeOutOfGui(delegate() { bool success = false; try { DataChangeEvent dataChange = new DataChangeEvent(); dataChange.IsLocalSource = true; dataChange.Inserts = new List <IDataChangeEntry>(0); dataChange.Updates = new List <IDataChangeEntry>(); dataChange.Deletes = new List <IDataChangeEntry>(); for (int a = objectsToRevert.Count; a-- > 0;) { Object objectToRevert = objectsToRevert[a]; IEntityMetaData metaData = ((IEntityMetaDataHolder)objectToRevert).Get__EntityMetaData(); Object id = metaData.IdMember.GetValue(objectToRevert, false); if (id == null) { dataChange.Deletes.Add(new DirectDataChangeEntry(objectToRevert)); continue; } dataChange.Updates.Add(new DataChangeEntry(metaData.EntityType, ObjRef.PRIMARY_KEY_INDEX, id, null)); } EventDispatcher.DispatchEvent(dataChange, DateTime.Now, -1); success = true; } finally { if (revertChangesFinishedCallback != null) { revertChangesFinishedCallback.Invoke(success); } } }); } else { // Commented the following part from Ambeth 0.130 and use the part from Ambeth 0.129 due to a deadlock in the merge process: //GuiThreadHelper.InvokeOutOfGui(delegate() //{ // bool success1 = false; // try // { // IList<IDataChangeEntry> directObjectDeletes = new List<IDataChangeEntry>(); // IList<Object> initializedObjects = MergeController.ScanForInitializedObjects(objectsToRevert, true, null); // IList<IObjRef> orisToRevert = new List<IObjRef>(); // ISet<Object> persistedObjectsToRevert = new IdentityHashSet<Object>(); // for (int a = initializedObjects.Count; a-- > 0; ) // { // Object objectToRevert = initializedObjects[a]; // IEntityMetaData metaData = EntityMetaDataProvider.GetMetaData(objectToRevert.GetType()); // Object id = metaData.IdMember.GetValue(objectToRevert, false); // if (id == null) // { // directObjectDeletes.Add(new DirectDataChangeEntry(objectToRevert)); // continue; // } // persistedObjectsToRevert.Add(objectToRevert); // orisToRevert.Add(new ObjRef(metaData.EntityType, ObjRef.PRIMARY_KEY_INDEX, id, null)); // } // IList<Object> hardRefsToRootCacheValues = RootCache.GetObjects(orisToRevert, CacheDirective.CacheValueResult | CacheDirective.ReturnMisses); // for (int a = orisToRevert.Count; a-- > 0; ) // { // if (hardRefsToRootCacheValues[a] == null) // { // // Object could not be loaded/retrieved any more. So the ori refers to an invalid object // // We can not revert invalid objects and currently ignore them. They will raise exceptions if they will // // be tried to persist in a merge process any time in the future // orisToRevert.RemoveAt(a); // } // } // // We do nothing with the hardRef-list from the RootCache. It is only necessary to keep track of the instance reference on the stack // // To prohibit GC any potential WeakReferences in the meantime.... // GuiThreadHelper.InvokeInGuiAndWait(delegate() // { // IProcessResumeItem processResumeItem = WaitEventToResume(); // try // { // bool oldCacheModificationValue = CacheModification.IsActive; // CacheModification.IsActive = true; // bool oldFailEarlyModeActive = AbstractCache<Object>.FailEarlyModeActive; // AbstractCache<Object>.FailEarlyModeActive = true; // try // { // IList<IWritableCache> firstLevelCaches = FirstLevelCacheManager.SelectFirstLevelCaches(); // IList<Object> hardRefsToRootCacheValuesHere = hardRefsToRootCacheValues; // foreach (IWritableCache firstLevelCache in firstLevelCaches) // { // IList<Object> persistedObjectsInThisCache = firstLevelCache.GetObjects(orisToRevert, CacheDirective.FailEarly); // for (int a = persistedObjectsInThisCache.Count; a-- > 0; ) // { // Object persistedObjectInThisCache = persistedObjectsInThisCache[a]; // if (!persistedObjectsToRevert.Contains(persistedObjectInThisCache)) // { // continue; // } // RootCache.ApplyValues(persistedObjectInThisCache, (ICacheIntern)firstLevelCache); // } // } // for (int a = objectsToRevert.Count; a-- > 0; ) // { // Object objectToRevert = objectsToRevert[a]; // if (objectToRevert is IDataObject) // { // // Objects which are specified to be reverted loose their delete flag // ((IDataObject)objectToRevert).ToBeDeleted = false; // } // } // } // finally // { // AbstractCache<Object>.FailEarlyModeActive = oldFailEarlyModeActive; // CacheModification.IsActive = oldCacheModificationValue; // } // } // finally // { // if (processResumeItem != null) // { // processResumeItem.ResumeProcessingFinished(); // processResumeItem = null; // } // } // }); // if (directObjectDeletes.Count > 0) // { // DataChangeEvent dataChange = DataChangeEvent.Create(0, 0, 0); // dataChange.Deletes = directObjectDeletes; // EventDispatcher.DispatchEvent(dataChange, DateTime.Now, -1); // } // success1 = true; // } // finally // { // if (revertChangesFinishedCallback != null) // { // revertChangesFinishedCallback.Invoke(success1); // } // } //}); // Here comes the part from Ambeth 0.129: GuiThreadHelper.InvokeOutOfGui(delegate() { bool success1 = false; bool?success2 = null; bool?success3 = null; try { IList <IDataChangeEntry> directObjectDeletes = new List <IDataChangeEntry>(); List <IObjRef> objRefs = new List <IObjRef>(); List <ValueHolderRef> valueHolderKeys = new List <ValueHolderRef>(); IList <Object> initializedObjects = MergeController.ScanForInitializedObjects(objectsToRevert, true, null, objRefs, valueHolderKeys); IList <IObjRef> orisToRevert = new List <IObjRef>(); ISet <Object> persistedObjectsToRevert = new IdentityHashSet <Object>(); for (int a = initializedObjects.Count; a-- > 0;) { Object objectToRevert = initializedObjects[a]; IEntityMetaData metaData = ((IEntityMetaDataHolder)objectToRevert).Get__EntityMetaData(); Object id = metaData.IdMember.GetValue(objectToRevert, false); if (id == null) { directObjectDeletes.Add(new DirectDataChangeEntry(objectToRevert)); continue; } persistedObjectsToRevert.Add(objectToRevert); orisToRevert.Add(new ObjRef(metaData.EntityType, ObjRef.PRIMARY_KEY_INDEX, id, null)); } IList <Object> hardRefsToRootCacheValues = RootCache.GetObjects(orisToRevert, CacheDirective.CacheValueResult | CacheDirective.ReturnMisses); for (int a = orisToRevert.Count; a-- > 0;) { if (hardRefsToRootCacheValues[a] == null) { // Object could not be loaded/retrieved any more. So the ori refers to an invalid object // We can not revert invalid objects and currently ignore them. They will raise exceptions if they will // be tried to persist in a merge process any time in the future orisToRevert.RemoveAt(a); } } // We do nothing with the hardRef-list from the RootCache. It is only necessary to keep track of the instance reference on the stack // To prohibit GC any potential WeakReferences in the meantime.... success2 = false; GuiThreadHelper.InvokeInGui(delegate(Object state) { WaitEventToResume(delegate(IProcessResumeItem processResumeItem) { try { bool oldCacheModificationValue = CacheModification.Active; CacheModification.Active = true; bool oldFailEarlyModeActive = AbstractCache.FailInCacheHierarchyModeActive; AbstractCache.FailInCacheHierarchyModeActive = true; try { IList <IWritableCache> firstLevelCaches = FirstLevelCacheManager.SelectFirstLevelCaches(); IList <Object> hardRefsToRootCacheValuesHere = hardRefsToRootCacheValues; foreach (IWritableCache firstLevelCache in firstLevelCaches) { IList <Object> persistedObjectsInThisCache = firstLevelCache.GetObjects(orisToRevert, CacheDirective.FailEarly); for (int a = persistedObjectsInThisCache.Count; a-- > 0;) { Object persistedObjectInThisCache = persistedObjectsInThisCache[a]; if (!persistedObjectsToRevert.Contains(persistedObjectInThisCache)) { continue; } RootCache.ApplyValues(persistedObjectInThisCache, (ICacheIntern)firstLevelCache, null); } } for (int a = objectsToRevert.Count; a-- > 0;) { Object objectToRevert = objectsToRevert[a]; if (objectToRevert is IDataObject) { // Objects which are specified to be reverted loose their flags ((IDataObject)objectToRevert).ToBeDeleted = false; } } if (directObjectDeletes.Count == 0) { success2 = true; return; } } finally { AbstractCache.FailInCacheHierarchyModeActive = oldFailEarlyModeActive; CacheModification.Active = oldCacheModificationValue; } } finally { if (processResumeItem != null) { processResumeItem.ResumeProcessingFinished(); } } success3 = false; GuiThreadHelper.InvokeOutOfGui(delegate() { try { DataChangeEvent dataChange = DataChangeEvent.Create(0, 0, 0); dataChange.Deletes = directObjectDeletes; EventDispatcher.DispatchEvent(dataChange, DateTime.Now, -1); success3 = true; } finally { if (revertChangesFinishedCallback != null) { revertChangesFinishedCallback.Invoke(success3.Value); } } }); success2 = true; }, delegate(Exception e) { if (revertChangesFinishedCallback != null && success3 == null) { revertChangesFinishedCallback.Invoke(success2.Value); } }); }, null); success1 = true; } finally { if (revertChangesFinishedCallback != null && success2 == null && success3 == null) { revertChangesFinishedCallback.Invoke(success1); } } }); } }
public virtual void DataChanged(IDataChange dataChange, DateTime dispatchTime, long sequenceId) { dataChange = dataChange.Derive(InterestedEntityTypes); if (dataChange.IsEmpty) { return; } ISet <Object> directObjectsToDelete = null; ISet <Type> requestedTypes = new HashSet <Type>(); IDictionary <Type, IEntityMetaData> typeToMetaDataDict = new Dictionary <Type, IEntityMetaData>(); GuiThreadHelper.InvokeInGuiAndWait(delegate() { IList <T> entities = Model.Objects; for (int i = entities.Count; i-- > 0;) { Object entity = entities[i]; requestedTypes.Add(entity.GetType()); } }); IList <IDataChangeEntry> dataChangeEntries = dataChange.Inserts; for (int a = dataChangeEntries.Count; a-- > 0;) { requestedTypes.Add(dataChangeEntries[a].EntityType); } dataChangeEntries = dataChange.Updates; for (int a = dataChangeEntries.Count; a-- > 0;) { requestedTypes.Add(dataChangeEntries[a].EntityType); } dataChangeEntries = dataChange.Deletes; for (int a = dataChangeEntries.Count; a-- > 0;) { requestedTypes.Add(dataChangeEntries[a].EntityType); } IList <IEntityMetaData> metaDatas = EntityMetaDataProvider.GetMetaData(ListUtil.ToList(requestedTypes)); foreach (IEntityMetaData metaData in metaDatas) { typeToMetaDataDict[metaData.EntityType] = metaData; } bool consistsOnlyOfDirectDeletes = false; if (dataChange.Deletes.Count > 0) { consistsOnlyOfDirectDeletes = true; foreach (IDataChangeEntry deleteEntry in dataChange.Deletes) { if (deleteEntry is DirectDataChangeEntry) { if (directObjectsToDelete == null) { directObjectsToDelete = new IdentityHashSet <Object>(); } directObjectsToDelete.Add(((DirectDataChangeEntry)deleteEntry).Entry); } else { consistsOnlyOfDirectDeletes = false; } } } IList <T> interestingEntities = null; Object[] contextInformation = GetContextInformation(); IFilterDescriptor filterDescriptor = GetFilterDescriptor(); IList <ISortDescriptor> sortDescriptors = GetSortDescriptors(); IPagingRequest pagingRequest = GetPagingRequest(); IPagingResponse pagingResponse = null; List <IDataChangeEntry> modifiedEntries = new List <IDataChangeEntry>(); modifiedEntries.AddRange(dataChange.All); if (!consistsOnlyOfDirectDeletes) { interestingEntities = CacheContext.ExecuteWithCache(CacheProvider.GetCurrentCache(), delegate() { ConfigureCacheWithEagerLoads(Cache); if (Refresher is IPagingRefresher <T> ) { interestingEntities = new List <T>(); pagingResponse = ((IPagingRefresher <T>)Refresher).Refresh(modifiedEntries, filterDescriptor, sortDescriptors, pagingRequest, contextInformation); foreach (Object obj in pagingResponse.Result) { interestingEntities.Add((T)obj); } return(interestingEntities); } else { if (filterDescriptor != null || sortDescriptors != null) { contextInformation = new Object[2]; contextInformation[0] = filterDescriptor; contextInformation[1] = sortDescriptors; } return(((IRefresher <T>)Refresher).Refresh(modifiedEntries, contextInformation)); } }); } GuiThreadHelper.InvokeInGuiAndWait(delegate() { IList <T> entities = Model.Objects; ISet <T> entitiesToAdd = null; ISet <T> entitiesToRemove = null; IDictionary <T, T> entitiesToReplace = null; IDictionary <IObjRef, T> oldObjRefToOldEntityMap = null; bool mergeModel = false; if (interestingEntities != null && interestingEntities.Count > 0) { entitiesToAdd = new IdentityHashSet <T>(interestingEntities); entitiesToRemove = new IdentityHashSet <T>(entities); entitiesToReplace = new IdentityDictionary <T, T>(); oldObjRefToOldEntityMap = new Dictionary <IObjRef, T>(); mergeModel = true; } for (int i = entities.Count; i-- > 0;) { T oldEntity = entities[i]; if (directObjectsToDelete != null && directObjectsToDelete.Contains(oldEntity)) { if (entitiesToRemove != null) { entitiesToRemove.Remove(oldEntity); } Model.RemoveAt(i); continue; } Type oldEntityType = ProxyHelper.GetRealType(oldEntity.GetType()); PrimitiveMember idMember = typeToMetaDataDict[oldEntityType].IdMember; Object oldEntityId = idMember.GetValue(oldEntity, false); if (oldEntityId == null) { if (entitiesToRemove != null) { entitiesToRemove.Remove(oldEntity); } // Unpersisted object. This object should not be removed // only because of a background DCE continue; } bool entryRemoved = false; foreach (IDataChangeEntry deleteEntry in dataChange.Deletes) { if (deleteEntry is DirectDataChangeEntry) { continue; } Object id = deleteEntry.Id; if (!EqualsItems(oldEntityType, oldEntityId, deleteEntry.EntityType, id)) { continue; } if (entitiesToRemove != null) { entitiesToRemove.Remove(oldEntity); } Model.RemoveAt(i); entryRemoved = true; break; } if (entryRemoved) { continue; } if (mergeModel) { IObjRef oldObjRef = new ObjRef(oldEntityType, ObjRef.PRIMARY_KEY_INDEX, oldEntityId, null); T existingOldEntity = DictionaryExtension.ValueOrDefault(oldObjRefToOldEntityMap, oldObjRef); if (existingOldEntity == null) { oldObjRefToOldEntityMap.Add(oldObjRef, oldEntity); } else if (!Object.ReferenceEquals(existingOldEntity, oldEntity)) { // Force duplicate key exception oldObjRefToOldEntityMap.Add(oldObjRef, oldEntity); } } } if (oldObjRefToOldEntityMap != null && oldObjRefToOldEntityMap.Count > 0) { IDictionary <IObjRef, T> newObjRefToNewEntityMap = new Dictionary <IObjRef, T>(); for (int a = interestingEntities.Count; a-- > 0;) { T newEntity = interestingEntities[a]; Type newEntityType = ProxyHelper.GetRealType(newEntity.GetType()); PrimitiveMember idMember = typeToMetaDataDict[newEntityType].IdMember; Object newEntityId = idMember.GetValue(newEntity, false); IObjRef newObjRef = new ObjRef(newEntityType, ObjRef.PRIMARY_KEY_INDEX, newEntityId, null); newObjRefToNewEntityMap.Add(newObjRef, newEntity); } DictionaryExtension.Loop(oldObjRefToOldEntityMap, delegate(IObjRef objRef, T oldEntity) { T newEntity = DictionaryExtension.ValueOrDefault(newObjRefToNewEntityMap, objRef); if (newEntity == null) { // Nothing to do if current oldEntity has no corresponding newEntity return; } entitiesToAdd.Remove(newEntity); if (!Object.ReferenceEquals(oldEntity, newEntity) && (dataChange.IsLocalSource || !(oldEntity is IDataObject) || !((IDataObject)oldEntity).ToBeUpdated)) { entitiesToReplace[oldEntity] = newEntity; } entitiesToRemove.Remove(oldEntity); }); } if (mergeModel) { for (int a = entities.Count; a-- > 0;) { T item = entities[a]; if (entitiesToRemove.Contains(item)) { Model.RemoveAt(a); continue; } T replacingItem = DictionaryExtension.ValueOrDefault(entitiesToReplace, item); if (replacingItem != null) { Model.Replace(a, replacingItem); continue; } } IEnumerator <T> enumerator = entitiesToAdd.GetEnumerator(); while (enumerator.MoveNext()) { T entityToAdd = enumerator.Current; Model.Add(entityToAdd); } if (hasPagedViewModel) { UpdatePagingInformation(pagingResponse); } UpdateAfterDCE(); } }); }