private void RemoveSchedulingForInitiative(InternalEventScheduling es) { if (es?.Initiative is InternalInitiative init) { scheduledEventsForInitiatives.Remove(init, es); if (init.AutoRemove && !scheduledEventsForInitiatives.AnyValues(init)) { // Get rid of an AutoRemove Initiative when there are no more scheduled events referencing it scheduledEventsForInitiatives.Clear(init); oc.Remove(init); } } }
public void UnLinkGrid() { if (MyDataBC == null) { return; } var mi = myData as INotifyPropertyChanged; if (mi != null) { mi.PropertyChanged -= OnMyGridPropertyChanged; } var mbc = MyData as IBindableComponent; if (mbc != null) { mbc.DataBindings.Clear(); } for (int i = 0; i < gridRowList.Count; i++) { var rowdef = gridRowList[i]; try { rowdef.UnLinkRow(); } catch (Exception ex) { throw new Exception("UnLinkRow failed: " + rowdef.Name, ex); } } linkedRows.Clear(); LinkedCells.Clear(); }
/** * Set sharding value for database sharding only. * * <p>The sharding operator is {@code =}</p> * * @param value sharding value */ public void SetDatabaseShardingValue(IComparable value) { databaseShardingValues.Clear(); tableShardingValues.Clear(); databaseShardingValues.Add("", value); databaseShardingOnly = true; }
public void Clear_RemovesAll() { sut.Add("a", "c"); sut.Add("b", "c"); sut.Clear(); sut.Should().BeEmpty(); }
private void Apply(SagaKeysChangedEvent ev) { keys.Clear(); foreach (var namePair in ev.Keys) { keys.AddRange(namePair.Key, namePair.Value); } }
public void Clear(int size) { MultiValueDictionary <int, int> dict = CreateMVD(size); foreach (var iteration in Benchmark.Iterations) { MultiValueDictionary <int, int> copyDict = new MultiValueDictionary <int, int>(dict); using (iteration.StartMeasurement()) copyDict.Clear(); } }
void UpdateTraitsFilter() { filterTraits.Clear(); if (listTraits.SelectedIndices.Count > 0) { foreach (ListViewItem item in listTraits.SelectedItems) { filterTraits.AddValue(item.Group.Name, item.Text); } } }
public void Clear_ShouldRemoveAllValues() { _target.Add("A", "A"); _target.Add("A", "B"); _target.Add("B", "A"); _target.Add("B", "B"); _target.Clear(); var result = _target.ContainsKey("A") || _target.ContainsKey("B"); Assert.False(result); }
public void Dispose() { var conns = _deviceObservers.Values.SelectMany(c => c).ToList(); _deviceObservers.Clear(); if (conns.Any()) { foreach (var c in conns) { c.Dispose(); } } }
public static void ShouldClear() { var multiDict = new MultiValueDictionary<string, string>(); multiDict.AddRange("key2", values2); multiDict.AddRange("key1", values1); multiDict.Add("key3", "海亀"); multiDict.Clear(); IReadOnlyCollection<string> values; Assert.IsFalse(multiDict.TryGetValue("海亀", out values)); Assert.IsFalse(multiDict.TryGetValue("key1", out values)); Assert.IsFalse(multiDict.TryGetValue("key2", out values)); Assert.IsFalse(multiDict.TryGetValue("key3", out values)); }
///<summary>Restores the light sources that were temporarily removed when UpdateBeforeOpacityChange was called. /// (UpdateBeforeOpacityChange MUST be called immediately before changing the opacity.)</summary> public void UpdateAfterOpacityChange() { if (!midOpacityUpdate) { throw new InvalidOperationException("This method can only be called to finish an opacity update"); } midOpacityUpdate = false; foreach (KeyValuePair <Point, int> pair in tempRemovedLights.GetAllKeyValuePairs()) { UpdateBrightnessWithinRadius(pair.Key, pair.Value, 1); } tempRemovedLights.Clear(); }
public void MultiValueDictionaryClearTest() { MultiValueDictionary <Int32, String> dictionary = new MultiValueDictionary <Int32, String>(); foreach (KeyValuePair <Int32, List <String> > item in _items) { dictionary.Add(item.Key, item.Value); } Assert.AreEqual(10, dictionary.Count()); dictionary.Clear(); Assert.AreEqual(0, dictionary.Count()); }
public static void ShouldClear() { var multiDict = new MultiValueDictionary <string, string>(); multiDict.AddRange("key2", values2); multiDict.AddRange("key1", values1); multiDict.Add("key3", "海亀"); multiDict.Clear(); IReadOnlyCollection <string> values; Assert.IsFalse(multiDict.TryGetValue("海亀", out values)); Assert.IsFalse(multiDict.TryGetValue("key1", out values)); Assert.IsFalse(multiDict.TryGetValue("key2", out values)); Assert.IsFalse(multiDict.TryGetValue("key3", out values)); }
public void ClearingDictionaryShouldResultInCountZero() { var dict = new MultiValueDictionary <int, string>(() => new HashSet <string>()) { { 1, "one" }, { 1, "een" }, { 2, "two" }, { 2, "twee" }, { 2, "deux" } }; dict.Clear(); Assert.Equal(0, dict.Count); }
/// <summary> /// At end of update dictionary needs to be erased.(?) /// </summary> /// <param name="gameTime"></param> public void update(GameTime gameTime) { // Go through each collision foreach (Tangible key in collisions.Keys) { foreach (Tangible value in collisions.GetValues(key, false)) { //System.Console.WriteLine("Resolving collision " + key.GetType().Name + " with " + value.GetType().Name + " at " + gameTime.TotalGameTime.TotalMilliseconds); key.collide(value, gameTime); } } //System.Console.WriteLine("Before collisions.Count " + collisions.Count); collisions.Clear(); //System.Console.WriteLine("After collisions.Count " + collisions.Count); }
internal void CommitDestroy() { foreach (var child in Transform.Children.ToArray()) { child.GameObject.CommitDestroy(); } foreach (var componentList in _components) { foreach (var component in componentList.Value) { component.InternalRemoved(_registry); } } _components.Clear(); Destroyed?.Invoke(this); InternalDestroyCommitted.Invoke(this); }
private static void RefreshServices() { ServiceCacheLock.EnterWriteLock(); ServiceCacheTime = DateTime.Now; ServiceCache.Clear(); ServiceCacheByPID.Clear(); foreach (ServiceController sc in ServiceController.GetServices()) { ServiceInfo info = new ServiceInfo(sc); if (!ServiceCache.ContainsKey(sc.ServiceName)) // should not happen but in case { ServiceCache.Add(sc.ServiceName, info); } if (info.LastKnownPID != -1) { ServiceCacheByPID.Add(info.LastKnownPID, info); } } // this takes roughly 30 ms ServiceCacheLock.ExitWriteLock(); }
public static void Init() { db.CreateTable <DBWord>(); db.CreateTable <DBMeaning>(); db.CreateTable <DBTranslation>(); words.Clear(); means.Clear(); eles.Clear(); WrongCount = 0; foreach (var w in db.Table <DBWord>()) { var s = w.ToStat(); words.Add(s, w.Id); eles.Add(s); if (s.wrong > 0) { WrongCount += s.wrong; } WrongCount++; } foreach (var m in db.Table <DBMeaning>()) { var s = m.ToStat(); means.Add(s, m.Id); eles.Add(s); if (s.wrong > 0) { WrongCount += s.wrong; } WrongCount++; } e2c.Clear(); c2e.Clear(); foreach (var t in db.Table <DBTranslation>()) { e2c.Add(t.Wid, t.Mid); c2e.Add(t.Mid, t.Wid); } updTimeAll = updTimeDetail = DateTime.Now.Ticks; }
public static Automaton NfaToDfa(Automaton nfa, out MultiValueDictionary<State, State> dfaStatesToNfa) { var dfa = new Automaton(); dfa.CaptureNames = nfa.CaptureNames; var dfaStartState = dfa.AddState(); dfa.StartState = dfaStartState; var nfaTransitionsToDfa = new MultiValueDictionary<Transition, Transition>(); var transitionClasses = new List<Transition>(); var mergeStates = new HashSet<State>(); dfaStatesToNfa = new MultiValueDictionary<State, State>(); dfaStatesToNfa.Add(dfaStartState, nfa.StartState); //不动点算法,不能使用 foreach! for(int i = 0; i < dfa.States.Count; ++i) { var curDfaState = dfa.States[i]; var nfaStates = dfaStatesToNfa[curDfaState]; foreach(var nfaState in nfaStates) { foreach(var outTransition in nfaState.Output) { if (!nfaTransitionsToDfa.Values.SelectMany(transitions => transitions).Contains(outTransition)) { transitionClasses.Add(outTransition); nfaTransitionsToDfa.Add(outTransition, outTransition); } } } foreach(var transitionClass in transitionClasses) { var nfaTransitions = nfaTransitionsToDfa[transitionClass]; foreach(var nfaTransition in nfaTransitions) { var state = nfaTransition.End; if (!mergeStates.Contains(state)) mergeStates.Add(state); } mergeStates.OrderBy(state => state); //mergeStates 是候选的一个 DFA 状态。在这之前,还需要判断:这个候选状态是否已经存在于 DFA 中了? //var isContained = dfaStatesToNfa.Values.Contains((IReadOnlyCollection<State>)mergeStates); State newDfaState = null; foreach(var dfaState in dfaStatesToNfa.Keys) { var prevNfaStates = dfaStatesToNfa[dfaState]; if (prevNfaStates.Count == mergeStates.Count && prevNfaStates.SequenceEqual(mergeStates)) { newDfaState = dfaState; break; } } if(newDfaState == null) { newDfaState = dfa.AddState(); dfaStatesToNfa.AddRange(newDfaState, mergeStates); newDfaState.IsFinalState = mergeStates.Any(state => state.IsFinalState); } var dfaTransition = dfa.AddTransition(curDfaState, newDfaState, transitionClass.TransitionType); dfaTransition.Capture = transitionClass.Capture; dfaTransition.Range = transitionClass.Range; dfaTransition.Index = transitionClass.Index; mergeStates.Clear(); } transitionClasses.Clear(); nfaTransitionsToDfa.Clear(); } return dfa; }
public void Rebuild( ) { //Debug.Log( "Rebuilding Uni2D Asset Table..." ); m_oAtlasGUIDSpritePrefabGUIDsMultiDict.Clear( ); m_oTextureGUIDAtlasGUIDsMultiDict.Clear( ); m_oTextureGUIDClipGUIDsMultiDict.Clear( ); m_oTextureGUIDSpritePrefabGUIDsMultiDict.Clear( ); m_oAtlasPathGUIDDict.Clear( ); m_oClipPathGUIDDict.Clear( ); // Iterate project's assets string[] rAssetPaths = AssetDatabase.GetAllAssetPaths( ); int iAssetCount = rAssetPaths.Length; float fInvAssetCount = 1.0f / (float)iAssetCount; int iProcessedAssets = 0; try { foreach (string rPath in rAssetPaths) { EditorUtility.DisplayProgressBar("Uni2D - Asset Table Rebuilding Progress", iProcessedAssets + " out of " + iAssetCount + " asset(s) processed...", fInvAssetCount * iProcessedAssets); Object rAssetObject = null; // Might be an atlas or a clip if (rPath.EndsWith(".prefab")) { rAssetObject = AssetDatabase.LoadAssetAtPath(rPath, typeof(Uni2DTextureAtlas)); if (rAssetObject != null) // It's an atlas { Uni2DTextureAtlas rAtlasAsset = (Uni2DTextureAtlas)rAssetObject; string rAtlasGUID = AssetDatabase.AssetPathToGUID(rPath); foreach (string rTextureGUID in rAtlasAsset.GetTextureGUIDs( )) { this.AddAtlasUsingTexture(rAtlasGUID, rTextureGUID); } m_oAtlasPathGUIDDict.Add(rPath, rAtlasGUID); rAtlasAsset = null; EditorUtility.UnloadUnusedAssets( ); } rAssetObject = AssetDatabase.LoadAssetAtPath(rPath, typeof(Uni2DAnimationClip)); if (rAssetObject != null) // It's an animation clip { Uni2DAnimationClip rAnimationClipAsset = (Uni2DAnimationClip)rAssetObject; string rAnimationClipGUID = AssetDatabase.AssetPathToGUID(rPath); foreach (string rTextureGUID in rAnimationClipAsset.GetAllFramesTextureGUIDs( )) { this.AddClipUsingTexture(rAnimationClipGUID, rTextureGUID); } m_oClipPathGUIDDict.Add(rPath, rAnimationClipGUID); rAnimationClipAsset = null; EditorUtility.UnloadUnusedAssets( ); } rAssetObject = AssetDatabase.LoadAssetAtPath(rPath, typeof(GameObject)); if (rAssetObject != null) // It's a sprite prefab { GameObject rPrefabAsset = (GameObject)rAssetObject; string rPrefabGUID = AssetDatabase.AssetPathToGUID(rPath); Uni2DSprite[] rSpritePrefabComponents = rPrefabAsset.GetComponentsInChildren <Uni2DSprite>(true); foreach (Uni2DSprite rSpritePrefabComponent in rSpritePrefabComponents) { Uni2DEditorSpriteSettings rSpriteSettings = rSpritePrefabComponent.SpriteSettings; this.AddSpritePrefabUsingTexture(rPrefabGUID, rSpriteSettings.textureContainer.GUID); if (rSpriteSettings.atlas != null) { this.AddSpritePrefabUsingAtlas(rPrefabGUID, Uni2DEditorUtils.GetUnityAssetGUID(rSpriteSettings.atlas)); } } rPrefabAsset = null; rSpritePrefabComponents = null; EditorUtility.UnloadUnusedAssets( ); } } ++iProcessedAssets; } } finally { this.Save( ); EditorUtility.UnloadUnusedAssets( ); EditorUtility.SetDirty(this); EditorUtility.ClearProgressBar( ); } //Debug.Log( "Uni2D Asset Table Rebuild: Done." ); }
public void Clear(int size) { MultiValueDictionary<int, int> dict = CreateMVD(size); foreach (var iteration in Benchmark.Iterations) { MultiValueDictionary<int, int> copyDict = new MultiValueDictionary<int, int>(dict); using (iteration.StartMeasurement()) copyDict.Clear(); } }
internal void Clear() { _indicesCoverage.Clear(); }
public void Reset() => _roomsConnections.Clear();
public void Clear() => _dict.Clear();
/// <summary> /// Initialize the <see cref="NntpArticleBuilder"/> from the given <see cref="NntpArticle"/>. /// All properties are overwritten. /// </summary> /// <param name="article">The <see cref="NntpArticle"/> to initialize the <see cref="NntpArticleBuilder"/> with.</param> /// <returns>The <see cref="NntpArticleBuilder"/> so that additional calls can be chained.</returns> public NntpArticleBuilder InitializeFrom(NntpArticle article) { messageId = null; from = null; subject = null; headers.Clear(); body.Clear(); groups.Clear(); foreach (KeyValuePair <string, ICollection <string> > header in article.Headers) { foreach (string value in header.Value) { switch (header.Key) { case NntpHeaders.MessageId: // skip additional messageid's break; case NntpHeaders.From: if (from == null) { from = value; } break; case NntpHeaders.Subject: if (subject == null) { subject = value; } break; case NntpHeaders.Date: if (dateTime == null) { if (DateTimeOffset.TryParseExact(value, dateFormat, CultureInfo.InvariantCulture, DateTimeStyles.None, out DateTimeOffset headerDateTime)) { dateTime = headerDateTime; } } break; case NntpHeaders.Newsgroups: // convert group header to list of groups, do not add as header AddGroups(value); break; default: headers.Add(header.Key, value); break; } } } body.AddRange(article.Body); messageId = article.MessageId; return(this); }
public static Automaton NfaToDfa(Automaton nfa, out MultiValueDictionary <State, State> dfaStatesToNfa) { var dfa = new Automaton(); dfa.CaptureNames = nfa.CaptureNames; var dfaStartState = dfa.AddState(); dfa.StartState = dfaStartState; var nfaTransitionsToDfa = new MultiValueDictionary <Transition, Transition>(); var transitionClasses = new List <Transition>(); var mergeStates = new HashSet <State>(); dfaStatesToNfa = new MultiValueDictionary <State, State>(); dfaStatesToNfa.Add(dfaStartState, nfa.StartState); //不动点算法,不能使用 foreach! for (int i = 0; i < dfa.States.Count; ++i) { var curDfaState = dfa.States[i]; var nfaStates = dfaStatesToNfa[curDfaState]; foreach (var nfaState in nfaStates) { foreach (var outTransition in nfaState.Output) { if (!nfaTransitionsToDfa.Values.SelectMany(transitions => transitions).Contains(outTransition)) { transitionClasses.Add(outTransition); nfaTransitionsToDfa.Add(outTransition, outTransition); } } } foreach (var transitionClass in transitionClasses) { var nfaTransitions = nfaTransitionsToDfa[transitionClass]; foreach (var nfaTransition in nfaTransitions) { var state = nfaTransition.End; if (!mergeStates.Contains(state)) { mergeStates.Add(state); } } mergeStates.OrderBy(state => state); //mergeStates 是候选的一个 DFA 状态。在这之前,还需要判断:这个候选状态是否已经存在于 DFA 中了? //var isContained = dfaStatesToNfa.Values.Contains((IReadOnlyCollection<State>)mergeStates); State newDfaState = null; foreach (var dfaState in dfaStatesToNfa.Keys) { var prevNfaStates = dfaStatesToNfa[dfaState]; if (prevNfaStates.Count == mergeStates.Count && prevNfaStates.SequenceEqual(mergeStates)) { newDfaState = dfaState; break; } } if (newDfaState == null) { newDfaState = dfa.AddState(); dfaStatesToNfa.AddRange(newDfaState, mergeStates); newDfaState.IsFinalState = mergeStates.Any(state => state.IsFinalState); } var dfaTransition = dfa.AddTransition(curDfaState, newDfaState, transitionClass.TransitionType); dfaTransition.Capture = transitionClass.Capture; dfaTransition.Range = transitionClass.Range; dfaTransition.Index = transitionClass.Index; mergeStates.Clear(); } transitionClasses.Clear(); nfaTransitionsToDfa.Clear(); } return(dfa); }
public virtual void BasicOperationsTest() { var data = new MultiValueDictionary <TKey, TValue>(); var key0 = NextKey(); var key1 = NextKey(); var value00 = NextValue(); var value01 = NextValue(); var value10 = NextValue(); var value11 = NextValue(); TValue v; TValue[] vs; var xvs = new List <TValue>(); // single key, single value data.Add(key0, value00); Assert.True(data.ContainsKey(key0)); Assert.True(((ICollection <KeyValuePair <TKey, TValue> >)data).Contains(new KeyValuePair <TKey, TValue>(key0, value00))); Assert.False(((ICollection <KeyValuePair <TKey, TValue> >)data).Contains(new KeyValuePair <TKey, TValue>(key0, value01))); Assert.True(data.TryGetValue(key0, out v)); Assert.Equal(value00, v); Assert.True(data.TryGetValues(key0, out vs)); Assert.NotNull(vs); Assert.Single(vs, v); xvs.Clear(); Assert.True(data.TryGetValues(key0, xvs)); Assert.Single(xvs, v); var count = data.Count; Assert.Equal(1, count); count = data.Count(); Assert.Equal(1, count); Assert.Single(data.Keys, key0); data.Clear(); Assert.Empty(data); // single key, two values (added separately) data.Add(key0, value00); data.Add(key0, value01); Assert.True(data.ContainsKey(key0)); Assert.True(((ICollection <KeyValuePair <TKey, TValue> >)data).Contains(new KeyValuePair <TKey, TValue>(key0, value00))); Assert.True(((ICollection <KeyValuePair <TKey, TValue> >)data).Contains(new KeyValuePair <TKey, TValue>(key0, value01))); Assert.True(data.TryGetValue(key0, out v)); Assert.True(EqualityComparer <TValue> .Default.Equals(value00, v) || EqualityComparer <TValue> .Default.Equals(value01, v)); Assert.True(data.TryGetValues(key0, out vs)); Assert.NotNull(vs); Assert.True(HashSet <TValue> .CreateSetComparer().Equals(new HashSet <TValue>(vs), new HashSet <TValue> { value00, value01 })); xvs.Clear(); Assert.True(data.TryGetValues(key0, xvs)); count = xvs.Count; Assert.Equal(2, count); Assert.Contains(value00, xvs); Assert.Contains(value01, xvs); count = data.Count; Assert.Equal(2, count); count = data.Count(); Assert.Equal(2, count); Assert.Single(data.Keys, key0); Assert.True(((ICollection <KeyValuePair <TKey, TValue> >)data).Remove(new KeyValuePair <TKey, TValue>(key0, value00))); count = data.Count; Assert.Equal(1, count); count = data.Count(); Assert.Equal(1, count); data.Add(key0, value00); Assert.Equal(2, data.Remove(key0)); Assert.Empty(data); // single key, two values (added as enumerable) data.Add(key0, value00, value01); Assert.True(data.ContainsKey(key0)); Assert.True(data.TryGetValue(key0, out v)); Assert.True(EqualityComparer <TValue> .Default.Equals(value00, v) || EqualityComparer <TValue> .Default.Equals(value01, v)); Assert.True(data.TryGetValues(key0, out vs)); Assert.NotNull(vs); Assert.True(HashSet <TValue> .CreateSetComparer().Equals(new HashSet <TValue>(vs), new HashSet <TValue> { value00, value01 })); count = data.Count; Assert.Equal(2, count); count = data.Count(); Assert.Equal(2, count); Assert.Single(data.Keys, key0); data.Set(key0, value01); count = data.Count; Assert.Equal(1, count); count = data.Count(); Assert.Equal(1, count); data.Set(key0, value00, value01); Assert.Equal(2, data.Remove(key0)); Assert.Empty(data); // single key, two values (added as keyvalue pairs) ((ICollection <KeyValuePair <TKey, TValue> >)data).Add(new KeyValuePair <TKey, TValue>(key0, value00)); ((ICollection <KeyValuePair <TKey, TValue> >)data).Add(new KeyValuePair <TKey, TValue>(key0, value01)); Assert.True(data.ContainsKey(key0)); Assert.True(((ICollection <KeyValuePair <TKey, TValue> >)data).Contains(new KeyValuePair <TKey, TValue>(key0, value00))); Assert.True(((ICollection <KeyValuePair <TKey, TValue> >)data).Contains(new KeyValuePair <TKey, TValue>(key0, value01))); Assert.True(data.TryGetValue(key0, out v)); Assert.True(EqualityComparer <TValue> .Default.Equals(value00, v) || EqualityComparer <TValue> .Default.Equals(value01, v)); Assert.True(data.TryGetValues(key0, out vs)); Assert.NotNull(vs); Assert.True(HashSet <TValue> .CreateSetComparer().Equals(new HashSet <TValue>(vs), new HashSet <TValue> { value00, value01 })); count = data.Count; Assert.Equal(2, count); count = data.Count(); Assert.Equal(2, count); Assert.Single(data.Keys, key0); Assert.True(((ICollection <KeyValuePair <TKey, TValue> >)data).Remove(new KeyValuePair <TKey, TValue>(key0, value00))); count = data.Count; Assert.Equal(1, count); count = data.Count(); Assert.Equal(1, count); data.Add(key0, value00); Assert.Equal(2, data.Remove(key0)); Assert.Empty(data); // two keys, two values (added separately) data.Add(key0, value00); data.Add(key0, value01); data.Add(key1, value10); data.Add(key1, value11); Assert.True(data.ContainsKey(key0)); Assert.True(data.ContainsKey(key1)); Assert.True(((ICollection <KeyValuePair <TKey, TValue> >)data).Contains(new KeyValuePair <TKey, TValue>(key0, value00))); Assert.True(((ICollection <KeyValuePair <TKey, TValue> >)data).Contains(new KeyValuePair <TKey, TValue>(key0, value01))); Assert.True(((ICollection <KeyValuePair <TKey, TValue> >)data).Contains(new KeyValuePair <TKey, TValue>(key1, value10))); Assert.True(((ICollection <KeyValuePair <TKey, TValue> >)data).Contains(new KeyValuePair <TKey, TValue>(key1, value11))); Assert.False(((ICollection <KeyValuePair <TKey, TValue> >)data).Contains(new KeyValuePair <TKey, TValue>(key1, value00))); Assert.False(((ICollection <KeyValuePair <TKey, TValue> >)data).Contains(new KeyValuePair <TKey, TValue>(key1, value01))); Assert.False(((ICollection <KeyValuePair <TKey, TValue> >)data).Contains(new KeyValuePair <TKey, TValue>(key0, value10))); Assert.False(((ICollection <KeyValuePair <TKey, TValue> >)data).Contains(new KeyValuePair <TKey, TValue>(key0, value11))); Assert.True(data.TryGetValue(key0, out v)); Assert.True(EqualityComparer <TValue> .Default.Equals(value00, v) || EqualityComparer <TValue> .Default.Equals(value01, v)); Assert.True(data.TryGetValues(key0, out vs)); Assert.NotNull(vs); Assert.True(HashSet <TValue> .CreateSetComparer().Equals(new HashSet <TValue>(vs), new HashSet <TValue> { value00, value01 })); xvs.Clear(); Assert.True(data.TryGetValues(key0, xvs)); count = xvs.Count; Assert.Equal(2, count); Assert.Contains(value00, xvs); Assert.Contains(value01, xvs); Assert.True(data.TryGetValue(key1, out v)); Assert.True(EqualityComparer <TValue> .Default.Equals(value10, v) || EqualityComparer <TValue> .Default.Equals(value11, v)); Assert.True(data.TryGetValues(key1, out vs)); Assert.NotNull(vs); Assert.True(HashSet <TValue> .CreateSetComparer().Equals(new HashSet <TValue>(vs), new HashSet <TValue> { value10, value11 })); xvs.Clear(); Assert.True(data.TryGetValues(key1, xvs)); count = xvs.Count; Assert.Equal(2, count); Assert.Contains(value10, xvs); Assert.Contains(value11, xvs); count = data.Count; Assert.Equal(4, count); count = data.Count(); Assert.Equal(4, count); Assert.True(HashSet <TKey> .CreateSetComparer().Equals(new HashSet <TKey>(data.Keys), new HashSet <TKey> { key0, key1 })); count = data.Keys.Count(); Assert.Equal(2, count); Assert.Equal(2, data.Remove(key0)); count = data.Count; Assert.Equal(2, count); count = data.Count(); Assert.Equal(2, count); data.Clear(); Assert.Empty(data); }
private void IndexBalances(ChainBase chain, string checkpointName, Func <uint256, Transaction, uint256, BlockHeader, int, IEnumerable <OrderedBalanceChange> > extract) { SetThrottling(); BlockingCollection <OrderedBalanceChange[]> indexedEntries = new BlockingCollection <OrderedBalanceChange[]>(100); var tasks = CreateTaskPool(indexedEntries, (entries) => Index(entries.Select(e => e.ToEntity()), this.Configuration.GetBalanceTable()), 30); using (IndexerTrace.NewCorrelation("Import balances " + checkpointName + " to azure started").Open()) { this.Configuration.GetBalanceTable().CreateIfNotExists(); var buckets = new MultiValueDictionary <string, OrderedBalanceChange>(); using (var storedBlocks = Enumerate(checkpointName, chain)) { foreach (var block in storedBlocks) { foreach (var tx in block.Block.Transactions) { var txId = tx.GetHash(); try { var entries = extract(txId, tx, block.BlockId, block.Block.Header, block.Height); foreach (var entry in entries) { buckets.Add(entry.PartitionKey, entry); var bucket = buckets[entry.PartitionKey]; if (bucket.Count == 100) { indexedEntries.Add(bucket.ToArray()); buckets.Remove(entry.PartitionKey); } } if (storedBlocks.NeedSave) { foreach (var kv in buckets.AsLookup().ToArray()) { indexedEntries.Add(kv.ToArray()); } buckets.Clear(); tasks.Stop(); storedBlocks.SaveCheckpoint(); tasks.Start(); } } catch (Exception ex) { IndexerTrace.ErrorWhileImportingBalancesToAzure(ex, txId); throw; } } } foreach (var kv in buckets.AsLookup().ToArray()) { indexedEntries.Add(kv.ToArray()); } tasks.Stop(); storedBlocks.SaveCheckpoint(); } } }