/// <summary> /// Locates the changes between the prior and post state of the modules.. /// </summary> /// <param name="modules_prior">List of the available modules prior to the update.</param> /// <param name="modules_post">List of the available modules after the update.</param> private void PrintChanges(List<CkanModule> modules_prior, List<CkanModule> modules_post) { var prior = new HashSet<CkanModule>(modules_prior, new NameComparer()); var post = new HashSet<CkanModule>(modules_post, new NameComparer()); var added = new HashSet<CkanModule>(post.Except(prior, new NameComparer())); var removed = new HashSet<CkanModule>(prior.Except(post, new NameComparer())); var unchanged = post.Intersect(prior);//Default compare includes versions var updated = post.Except(unchanged).Except(added).Except(removed).ToList(); // Print the changes. user.RaiseMessage("Found {0} new modules, {1} removed modules and {2} updated modules.", added.Count(), removed.Count(), updated.Count()); if (added.Count > 0) { PrintModules("New modules [Name (CKAN identifier)]:", added); } if (removed.Count > 0) { PrintModules("Removed modules [Name (CKAN identifier)]:", removed); } if (updated.Count > 0) { PrintModules("Updated modules [Name (CKAN identifier)]:", updated); } }
public override void OnUpdateList () { base.OnUpdateList (); StackFrame frame = DebuggingService.CurrentFrame; if (frame == null || !FrameEquals (frame, lastFrame)) { tree.ClearExpressions (); lastExpressions = null; } lastFrame = frame; if (frame == null) return; //FIXME: tree should use the local refs rather than expressions. ATM we exclude items without names var expr = new HashSet<string> (frame.GetAllLocals ().Select (i => i.Name) .Where (n => !string.IsNullOrEmpty (n) && n != "?")); //add expressions not in tree already, remove expressions that are longer valid if (lastExpressions != null) { foreach (string rem in lastExpressions.Except (expr)) tree.RemoveExpression (rem); foreach (string rem in expr.Except (lastExpressions)) tree.AddExpression (rem); } else { tree.AddExpressions (expr); } lastExpressions = expr; }
public static List<DateTime> GetBusinessDays(DateTime dateFrom, DateTime dateTo) { HashSet<DateTime> holidays = new HashSet<DateTime>(); HashSet<DateTime> businessDaysSet = new HashSet<DateTime>(); for (int year=dateFrom.Year; year<=dateTo.Year; year++) { HashSet<DateTime> holidayList = GetHolidays(year); holidays.UnionWith(holidayList); } for (var dt = dateFrom; dt <= dateTo; dt = dt.AddDays(1)) {if ((dt.DayOfWeek == DayOfWeek.Saturday) || (dt.DayOfWeek == DayOfWeek.Sunday)) continue; else businessDaysSet.Add(dt); } List<DateTime> businessDays = businessDaysSet.Except(holidays).ToList(); businessDays.Sort((a,b)=>a.CompareTo(b)); return businessDays; }
IEnumerator LoadTagCoroutine(string id, string sceneName, string tagName) { var before = new HashSet<GameObject>((GameObject[])GameObject.FindObjectsOfType(typeof(GameObject))); Application.LoadLevelAdditive(sceneName); yield return new WaitForEndOfFrame(); var after = new HashSet<GameObject>((GameObject[])GameObject.FindObjectsOfType(typeof(GameObject))); var newObjects = after.Except(before).ToList(); var destroy = newObjects.Where (arg => arg.tag != tagName).ToArray(); foreach(var i in destroy) { var parent = i.transform.parent; while(parent && parent.tag != tagName) { parent = parent.transform.parent; } if(parent) continue; GameObject.DestroyImmediate(i); } newObjects.RemoveAll((obj) => !obj); Group.AddToGroup(id, newObjects); }
public void AllValuesInArrayAreIndexed() { var coll = GetCollection(); // Make sure property Tags is indexed coll.Indices.EnsureIndex("Tags"); // Insert something where Tags is list of values const string key = "a key of some sort"; var values = new HashSet<object> {"A", "B", DateTime.Now, null, Math.PI}; coll.Update(key, new {Tags = values}); // Now, extract what the index really contains var indexContent = new List<KeyValuePair<IndexValue, string>>(); coll.Indices.VisitIndex("Tags", indexContent.Add); // First of all, each index entry must point to our key foreach (var kv in indexContent) { Assert.AreEqual(key, kv.Value); } // Second, the index should contain the array values var indexValues = new HashSet<object>(indexContent.Select(kv => kv.Key.Value)); Assert.AreEqual(0, indexValues.Except(values).Count(), "Index values are too many"); Assert.AreEqual(0, values.Except(indexValues).Count(), "Index values are too feew"); }
public DiffResult DiffInputs(CompilerIO other) { var myInputSet = new HashSet<string>(Inputs); var otherInputSet = new HashSet<string>(other.Inputs); var additions = myInputSet.Except(otherInputSet); var deletions = otherInputSet.Except(myInputSet); return new DiffResult(additions, deletions); }
IEnumerator LoadCoroutine(string id, string sceneName) { var before = new HashSet<GameObject>((GameObject[])GameObject.FindObjectsOfType(typeof(GameObject))); Application.LoadLevelAdditive(sceneName); yield return 0; var after = new HashSet<GameObject>((GameObject[])GameObject.FindObjectsOfType(typeof(GameObject))); var newObjects = after.Except(before).ToList(); Group.AddToGroup(id, newObjects); }
/// <summary> /// 检查要设置的值是否存在于候选值列表中 /// </summary> /// <param name="values">所要设置的值</param> /// <param name="message">若不能设置,获取错误信息</param> /// <returns>是否可以设置</returns> protected virtual bool CanSetValues( HashSet<string> values, out string message ) { var invalidValue = values.Except( CandidateValues ).FirstOrDefault(); if ( invalidValue != null && !Form.Configuration.IgnoreInvailidValuesInGroupControl )//如果有一个设置的值不在候选值列表 { message = string.Format( "不能对控件设置值 \"{0}\"", invalidValue.First() ); return false; } message = null; return true; }
public void Run(Action<string> emitError, Action<string> emitWarning, Ruleset rules) { foreach (var actorInfo in rules.Actors) { if (actorInfo.Key.StartsWith("^", StringComparison.Ordinal)) continue; var granted = new HashSet<string>(); var consumed = new HashSet<string>(); foreach (var trait in actorInfo.Value.TraitInfos<ITraitInfo>()) { var fieldConsumed = trait.GetType().GetFields() .Where(x => x.HasAttribute<ConsumedConditionReferenceAttribute>()) .SelectMany(f => LintExts.GetFieldValues(trait, f, emitError)); var propertyConsumed = trait.GetType().GetProperties() .Where(x => x.HasAttribute<ConsumedConditionReferenceAttribute>()) .SelectMany(p => LintExts.GetPropertyValues(trait, p, emitError)); var fieldGranted = trait.GetType().GetFields() .Where(x => x.HasAttribute<GrantedConditionReferenceAttribute>()) .SelectMany(f => LintExts.GetFieldValues(trait, f, emitError)); var propertyGranted = trait.GetType().GetProperties() .Where(x => x.HasAttribute<GrantedConditionReferenceAttribute>()) .SelectMany(f => LintExts.GetPropertyValues(trait, f, emitError)); foreach (var c in fieldConsumed.Concat(propertyConsumed)) if (!string.IsNullOrEmpty(c)) consumed.Add(c); foreach (var g in fieldGranted.Concat(propertyGranted)) if (!string.IsNullOrEmpty(g)) granted.Add(g); } var unconsumed = granted.Except(consumed); if (unconsumed.Any()) emitWarning("Actor type `{0}` grants conditions that are not consumed: {1}".F(actorInfo.Key, unconsumed.JoinWith(", "))); var ungranted = consumed.Except(granted); if (ungranted.Any()) emitError("Actor type `{0}` consumes conditions that are not granted: {1}".F(actorInfo.Key, ungranted.JoinWith(", "))); if ((consumed.Any() || granted.Any()) && actorInfo.Value.TraitInfoOrDefault<UpgradeManagerInfo>() == null) emitError("Actor type `{0}` defines conditions but does not include an UpgradeManager".F(actorInfo.Key)); } }
public ActionResult Refresh() { var directory = HostingEnvironment.VirtualPathProvider.GetDirectory( VirtualPathUtility.ToAbsolute( templatePath ) ); var data = new HashSet<string>( dbUtility.Data( "SELECT virtualPath FROM Templates " ).Column<string>(), StringComparer.OrdinalIgnoreCase ); var local = new HashSet<string>( SearchFiles( directory ).Select( f => VirtualPathUtility.ToAppRelative( f.VirtualPath ) ) ); foreach ( var virtualPath in local.Except( data ) ) dbUtility.NonQuery( "INSERT INTO Templates ( virtualPath ) VALUES ( {0} )", virtualPath ); foreach ( var virtualPath in data.Except( local ) ) dbUtility.NonQuery( "DELETE Templates WHERE virtualPath = {0}", virtualPath ); return RedirectToAction( "List" ); }
public static void Update() { currentState = Keyboard.GetState(); HashSet <Keys> currentKeySet = new HashSet <Keys> (currentState.GetPressedKeys()); IEnumerable <Keys> pressedKeys = currentKeySet.Except(previousKeySet); IEnumerable <Keys> releasedKeys = previousKeySet.Except(currentKeySet); if (pressedKeys.Count() > 0) { FireKeyPressed(new KeyEvent(pressedKeys)); } if (releasedKeys.Count() > 0) { FireKeyReleased(new KeyEvent(releasedKeys)); } previousKeySet = currentKeySet; previousState = currentState; }
public static void AllStatesCanBeReached(IEnumerable<State> states) { var allStates = new HashSet<State>(states); var visitedStates = new HashSet<State>(); TraverseStateGraph(states.First(), visitedStates); var unreachableStates = allStates.Except(visitedStates).ToList(); if (unreachableStates.Count != 0) { Console.WriteLine("Unreachable states:"); foreach (var unreachableState in unreachableStates) { Console.WriteLine(unreachableState.Name); } } Assert.Equal(allStates.Count, visitedStates.Count); }
// cross check /Resources/Prefabs and Levels.xml if there are any item prefabs that exist only in one but not the other public void crossCheck() { // create a two sets of prefabs HashSet<string> resPrefabSet = new HashSet<string>(); HashSet<string> xmlPrefabSet = new HashSet<string>(); // Get prefabs from Levels.xml getLevelPrefabs(xmlPrefabSet); // Get prefabs from the /Resources/Prefabs folder getResPrefabs(resPrefabSet); // Cross checks foreach (string prefab in xmlPrefabSet.Except(resPrefabSet).ToList()) Debug.LogError(prefab + " is missing in the /Resorces/Prefabs folder but used in Levels.xml"); foreach (string prefab in resPrefabSet.Except(xmlPrefabSet).ToList()) Debug.Log(prefab + " exists in the /Resorces/Prefabs folder but not used in Levels.xml"); Debug.Log("Cross Check Done"); }
public void AssertNumberOfResultsIsConsistentOnRecompile(IEnumerable<IViewComputationResultModel> results) { HashSet<Tuple<string, ValueSpecification>> values = null; foreach (var result in results) { Assert.NotNull(result); var newValues = new HashSet<Tuple<string, ValueSpecification>>(result.AllResults.Select(r => Tuple.Create(r.CalculationConfiguration, r.ComputedValue.Specification))); if (values != null) { if (!values.SetEquals(newValues)) { var missing = values.Except(newValues).ToList(); var added = newValues.Except(values).ToList(); throw new Exception(string.Format("Previously missing {0} results, now {1}. Missing {2}. Added {3}", values.Count, newValues.Count, String.Join(",", missing), String.Join(",", added))); } } else { values = newValues; } } }
public void Should_Return_All_Metadata_From_Metadata_Repository_OnGet() { // Arrange var queryableList = this.ConstructQueryableList(); MetadataController controller = new MetadataController(); var metadataRepositoryMock = new Mock<IMetadataRepository>(); metadataRepositoryMock.Setup(x => x.GetAll()).Returns(queryableList).Verifiable(); controller.MetadataRepository = metadataRepositoryMock.Object; // Act var actionResult = controller.Get(); // Assert GenericValueResult<IEnumerable<Models.MetadataInfo>> results = actionResult as GenericValueResult<IEnumerable<Models.MetadataInfo>>; results.Should().NotBeNull("Wrong data type was returned from the controller"); results.Value.Count().Should().Be(queryableList.Count()); HashSet<int> receivedIds = new HashSet<int>(results.Value.Select(x => x.Id.Value).AsEnumerable()); HashSet<int> expectedIds = new HashSet<int>(queryableList.Select(x => x.Id).AsEnumerable()); expectedIds.Except(receivedIds).Count().Should().Be(0, "Result list should contain all the same IDs as the list in Repository"); metadataRepositoryMock.VerifyAll(); }
public ActionResult _RegisterPushTargets(int topicID, Dictionary<int, bool> users) { var topic = db.Topics.Find(topicID); if (topic.IsReadOnly) return HTTPStatus(HttpStatusCode.Forbidden, "Das Thema ist schreibgeschützt."); var desired = new HashSet<int>(users.Where(kvp => kvp.Value).Select(kvp => kvp.Key)); var actual = new HashSet<int>(db.PushNotifications.Where(pn => pn.TopicID == topicID).Select(pn => pn.UserID)); foreach (var userID in desired.Except(actual)) db.PushNotifications.Add(new PushNotification { TopicID = topicID, UserID = userID }); foreach (var userID in actual.Except(desired)) db.PushNotifications.RemoveRange(db.PushNotifications.Where(pn => pn.TopicID == topicID && pn.UserID == userID)); db.SaveChanges(); return _EditListTopic(topic); }
private string GetNewClonedDirectoryOrNulIfNoneCloned(IEnumerable<string> directoriesThatExistedBeforeCloning) { var dirs = new HashSet<string>(Directory.GetDirectories(_repoHoldingFolder)); return dirs.Except(directoriesThatExistedBeforeCloning).FirstOrDefault(); }
private void GetReferences(JObject lockFile) { var target = GetTargetOrAttemptFallback(lockFile, needsRuntimeIdentifier: false); var frameworkReferences = new HashSet<string>(StringComparer.OrdinalIgnoreCase); var fileNamesOfRegularReferences = new HashSet<string>(StringComparer.OrdinalIgnoreCase); foreach (var package in GetPackagesFromTarget(lockFile, target)) { foreach (var referenceItem in CreateItems(package, NuGetAssetTypeCompile, includePdbs: false)) { _references.Add(referenceItem); fileNamesOfRegularReferences.Add(Path.GetFileNameWithoutExtension(referenceItem.ItemSpec)); } if (IncludeFrameworkReferences) { var frameworkAssembliesArray = package.TargetObject["frameworkAssemblies"] as JArray; if (frameworkAssembliesArray != null) { foreach (var frameworkAssembly in frameworkAssembliesArray.OfType<JToken>()) { frameworkReferences.Add((string)frameworkAssembly); } } } } foreach (var frameworkReference in frameworkReferences.Except(fileNamesOfRegularReferences, StringComparer.OrdinalIgnoreCase)) { var item = new TaskItem(frameworkReference); item.SetMetadata(NuGetIsFrameworkReference, "true"); item.SetMetadata(NuGetSourceType, NuGetSourceType_Package); _references.Add(item); } }
void TestFindReferences(IEntity entity) { if (IgnoreEntity(entity)) return; FindReferences fr = new FindReferences(); fr.FindTypeReferencesEvenIfAliased = true; Stopwatch w = new Stopwatch(); var searchScopes = fr.GetSearchScopes(entity); foreach (var project in solution.Projects) { w.Restart(); HashSet<AstNode> foundReferences = new HashSet<AstNode>(); var interestingFiles = new HashSet<CSharpFile>(); foreach (var searchScope in searchScopes) { foreach (var unresolvedFile in fr.GetInterestingFiles(searchScope, project.Compilation)) { var file = project.Files.Single(f => f.FileName == unresolvedFile.FileName); Debug.Assert(file.UnresolvedTypeSystemForFile == unresolvedFile); // Skip file if it doesn't contain the search term if (searchScope.SearchTerm != null && file.OriginalText.IndexOf(searchScope.SearchTerm, StringComparison.Ordinal) < 0) continue; interestingFiles.Add(file); } } foreach (var file in interestingFiles) { fr.FindReferencesInFile(searchScopes, file.UnresolvedTypeSystemForFile, file.SyntaxTree, project.Compilation, delegate(AstNode node, ResolveResult result) { foundReferences.Add(node); }, CancellationToken.None); } w.Stop(); if (timings.ContainsKey(entity.EntityType)) { timings[entity.EntityType] += w.Elapsed; } else { timings[entity.EntityType] = w.Elapsed; } IEntity importedEntity = project.Compilation.Import(entity); HashSet<AstNode> expectedReferences; if (importedEntity == null || !referenceDict.TryGetValue(importedEntity, out expectedReferences)) { if (foundReferences.Any()) { // There aren't any expected references stored, but we found some references anyways: Console.WriteLine(); Console.WriteLine("Entity not in reference dictionary: " + entity); } return; } if (foundReferences.Except(expectedReferences).Any()) { Console.WriteLine(); Console.WriteLine("Reference mismatch for " + entity + ":"); var n = foundReferences.Except(expectedReferences).First(); Console.WriteLine("Found unexpected reference " + n + " (" + n.GetRegion() + ")"); } if (expectedReferences.Except(foundReferences).Any()) { Console.WriteLine(); Console.WriteLine("Reference mismatch for " + entity + ":"); var n = expectedReferences.Except(foundReferences).First(); Console.WriteLine("Did not find expected reference " + n + " (" + n.GetRegion() + ")"); } } if (entityCount.ContainsKey(entity.EntityType)) { entityCount[entity.EntityType]++; } else { entityCount[entity.EntityType] = 1; } }
List<ILNode> FindLoops(HashSet<ControlFlowNode> scope, ControlFlowNode entryPoint, bool excludeEntryPoint) { List<ILNode> result = new List<ILNode>(); // Do not modify entry data scope = new HashSet<ControlFlowNode>(scope); Queue<ControlFlowNode> agenda = new Queue<ControlFlowNode>(); agenda.Enqueue(entryPoint); while(agenda.Count > 0) { ControlFlowNode node = agenda.Dequeue(); // If the node is a loop header if (scope.Contains(node) && node.DominanceFrontier.Contains(node) && (node != entryPoint || !excludeEntryPoint)) { HashSet<ControlFlowNode> loopContents = FindLoopContent(scope, node); // If the first expression is a loop condition ILBasicBlock basicBlock = (ILBasicBlock)node.UserData; ILExpression condExpr; ILLabel trueLabel; ILLabel falseLabel; // It has to be just brtrue - any preceding code would introduce goto if(basicBlock.MatchSingleAndBr(ILCode.Brtrue, out trueLabel, out condExpr, out falseLabel)) { ControlFlowNode trueTarget; labelToCfNode.TryGetValue(trueLabel, out trueTarget); ControlFlowNode falseTarget; labelToCfNode.TryGetValue(falseLabel, out falseTarget); // If one point inside the loop and the other outside if ((!loopContents.Contains(trueTarget) && loopContents.Contains(falseTarget)) || (loopContents.Contains(trueTarget) && !loopContents.Contains(falseTarget)) ) { loopContents.RemoveOrThrow(node); scope.RemoveOrThrow(node); // If false means enter the loop if (loopContents.Contains(falseTarget) || falseTarget == node) { // Negate the condition condExpr = new ILExpression(ILCode.LogicNot, null, condExpr); ILLabel tmp = trueLabel; trueLabel = falseLabel; falseLabel = tmp; } ControlFlowNode postLoopTarget; labelToCfNode.TryGetValue(falseLabel, out postLoopTarget); if (postLoopTarget != null) { // Pull more nodes into the loop HashSet<ControlFlowNode> postLoopContents = FindDominatedNodes(scope, postLoopTarget); var pullIn = scope.Except(postLoopContents).Where(n => node.Dominates(n)); loopContents.UnionWith(pullIn); } // Use loop to implement the brtrue basicBlock.Body.RemoveTail(ILCode.Brtrue, ILCode.Br); basicBlock.Body.Add(new ILWhileLoop() { Condition = condExpr, BodyBlock = new ILBlock() { EntryGoto = new ILExpression(ILCode.Br, trueLabel), Body = FindLoops(loopContents, node, false) } }); basicBlock.Body.Add(new ILExpression(ILCode.Br, falseLabel)); result.Add(basicBlock); scope.ExceptWith(loopContents); } } // Fallback method: while(true) if (scope.Contains(node)) { result.Add(new ILBasicBlock() { Body = new List<ILNode>() { new ILLabel() { Name = "Loop_" + (nextLabelIndex++) }, new ILWhileLoop() { BodyBlock = new ILBlock() { EntryGoto = new ILExpression(ILCode.Br, (ILLabel)basicBlock.Body.First()), Body = FindLoops(loopContents, node, true) } }, }, }); scope.ExceptWith(loopContents); } } // Using the dominator tree should ensure we find the the widest loop first foreach(var child in node.DominatorTreeChildren) { agenda.Enqueue(child); } } // Add whatever is left foreach(var node in scope) { result.Add((ILNode)node.UserData); } scope.Clear(); return result; }
/// <summary> /// Given a list of symbols, determine which are not recommended at the same position in linked documents. /// </summary> /// <param name="expectedSymbols">The symbols recommended in the active context.</param> /// <param name="linkedContextSymbolLists">The symbols recommended in linked documents</param> /// <returns>The list of projects each recommended symbol did NOT appear in.</returns> protected Dictionary<ISymbol, List<ProjectId>> FindSymbolsMissingInLinkedContexts(HashSet<ISymbol> expectedSymbols, IEnumerable<Tuple<DocumentId, AbstractSyntaxContext, IEnumerable<ISymbol>>> linkedContextSymbolLists) { var missingSymbols = new Dictionary<ISymbol, List<ProjectId>>(LinkedFilesSymbolEquivalenceComparer.IgnoreAssembliesInstance); foreach (var linkedContextSymbolList in linkedContextSymbolLists) { var symbolsMissingInLinkedContext = expectedSymbols.Except(linkedContextSymbolList.Item3, LinkedFilesSymbolEquivalenceComparer.IgnoreAssembliesInstance); foreach (var missingSymbol in symbolsMissingInLinkedContext) { missingSymbols.GetOrAdd(missingSymbol, (m) => new List<ProjectId>()).Add(linkedContextSymbolList.Item1.ProjectId); } } return missingSymbols; }
void HandleNewTerrainsAndObjects() { m_oldKnownLocations = m_newKnownLocations; m_newKnownLocations = CollectLocations(); m_oldKnownObjects = m_newKnownObjects; m_newKnownObjects = CollectObjects(m_newKnownLocations); var revealedLocations = m_newKnownLocations.Except(m_oldKnownLocations); var revealedObjects = m_newKnownObjects.Except(m_oldKnownObjects); SendNewTerrains(revealedLocations); SendNewObjects(revealedObjects); }
private static void TraceToSource(Bus FromBus, Bus BusThatStartedItAll, HashSet<Bus> busesInThisTrace, HashSet<Bus> busesOnPath) { //start at FromBus, take a step away from FromBus. //If we're at the source, add the path that we took to BusesOnRouteToSource. //If we're at a dead-end, then stop tracing this branch. //If we hit a bus that's already on the route, then terminate and add the branch. var connectedBuses = FromBus.ConnectedTo.OfType<Line>().Select(line => line.ConnectedTo.OfType<Bus>().Except(FromBus.Yield()).Single()) //all the buses neighbouring this one .Except(busesInThisTrace) //exclude any buses we've already touched in this trace ; foreach (var bus in connectedBuses) { if (busesOnPath.Contains(bus)) //we're connected to the target bus. no further processing required on this branch. { busesOnPath.UnionWith(busesInThisTrace.Except(BusThatStartedItAll.Yield())); continue; } else { //keep searching! HashSet<Bus> NextStepTraceList; if (connectedBuses.Count() == 1) //if this is the only possible way forward, then just keep using the same thingy. { NextStepTraceList = busesInThisTrace; } else { NextStepTraceList = new HashSet<Bus>(busesInThisTrace); } NextStepTraceList.Add(bus); TraceToSource(bus, BusThatStartedItAll, NextStepTraceList, busesOnPath); } } }
private string[] GetMissingModules(HashSet<string> existingDatabase) { var searchPaths = PythonTypeDatabase.GetCachedDatabaseSearchPaths(DatabasePath); if (searchPaths == null) { // No cached search paths means our database is out of date. return existingDatabase .Except(RequiredBuiltinModules) .OrderBy(name => name, StringComparer.InvariantCultureIgnoreCase) .ToArray(); } return PythonTypeDatabase.GetDatabaseExpectedModules(_config.Version, searchPaths) .SelectMany() .Select(mp => mp.ModuleName) .Concat(RequiredBuiltinModules) .Where(m => !existingDatabase.Contains(m)) .OrderBy(name => name, StringComparer.InvariantCultureIgnoreCase) .ToArray(); }
/// <summary> /// Resyncs the user with our view of the neighbors /// </summary> /// <param name="newDrawDistance">The new DD for the user</param> /// <param name="resyncDelay">Delay before executing the resync. We delay on a region crossing because the viewer locks up sometimes when freeing memory</param> /// <returns></returns> private async Task CalculateAndResyncNeighbors(uint newDrawDistance, int resyncDelay) { uint xmin, xmax, ymin, ymax; Util.GetDrawDistanceBasedRegionRectangle((uint)newDrawDistance, _scene.RegionInfo.RegionLocX, _scene.RegionInfo.RegionLocY, out xmin, out xmax, out ymin, out ymax); //get our current neighbor list List<SimpleRegionInfo> knownNeighborsList = _scene.SurroundingRegions.GetKnownNeighborsWithinClientDD(newDrawDistance); Dictionary<ulong, SimpleRegionInfo> knownNeighborsDict = new Dictionary<ulong, SimpleRegionInfo>(); foreach (var neighbor in knownNeighborsList) { knownNeighborsDict.Add(neighbor.RegionHandle, neighbor); } HashSet<ulong> knownNeighbors = new HashSet<ulong>(knownNeighborsList.Select(x => x.RegionHandle)); List<ulong> deadRegions; List<ulong> newRegions; lock (_remotePresences) { //check the list of what we have vs what we should have HashSet<ulong> usersRegions = new HashSet<ulong>(); //add all regions from the presence foreach (var presence in _remotePresences.Values) { knownNeighborsDict[presence.PresenceInfo.RegionInfo.RegionHandle] = presence.PresenceInfo.RegionInfo; //dont put far regions into this update, they shouldnt be dropped by DD changes if (!presence.IsFarPresence) { usersRegions.Add(presence.PresenceInfo.RegionInfo.RegionHandle); } } // regions that we have but that we shouldnt have anymore deadRegions = new List<ulong>(usersRegions.Except(knownNeighbors)); // regions that we don't have that we need to add newRegions = new List<ulong>(knownNeighbors.Except(usersRegions)); } try { await _operationSemaphore.WaitAsync(); if (resyncDelay > 0) await Task.Delay(resyncDelay); await this.ResyncRegions(knownNeighborsDict, deadRegions, newRegions); } finally { _operationSemaphore.Release(); } }
void VerifyChanges(ICmObject[] expectedNewbies, ICmObject[] expectedDirtballs, ICmObjectId[] expectedGoners, IUnitOfWorkService m_uowService) { var newbies = new HashSet<ICmObjectId>(); var dirtballs = new HashSet<ICmObjectOrSurrogate>(new ObjectSurrogateEquater()); var goners = new HashSet<ICmObjectId>(); m_uowService.GatherChanges(newbies, dirtballs, goners); var setNewbies = new HashSet<ICmObjectId>(from obj in expectedNewbies select obj.Id); Assert.That(newbies.Except(setNewbies), Is.Empty, "some unexpected newbies were found"); Assert.That(setNewbies.Except(newbies), Is.Empty, "some expected newbies were not found"); var setDirtballs = new HashSet<ICmObjectOrSurrogate>(expectedDirtballs.Cast<ICmObjectOrSurrogate>()); Assert.That(dirtballs.Except(setDirtballs), Is.Empty, "some unexpected dirtballs were found"); Assert.That(setDirtballs.Except(dirtballs), Is.Empty, "some expected dirtballs were not found"); var setGoners = new HashSet<ICmObjectId>(expectedGoners); Assert.That(goners.Except(setGoners), Is.Empty, "some unexpected goners were found"); Assert.That(setGoners.Except(goners), Is.Empty, "some expected goners were not found"); }
/// <summary> /// 求两个Hash集合的差集(不改变原集合) /// 将返回其不在 second 中的元素 /// 注释:Except方法是IEnumrable的方法,也可用于List等 /// </summary> /// <param name="first"></param> /// <param name="compararSet"></param> /// <returns></returns> public static IList<int> setExcept(HashSet<int> first, HashSet<int> second) { return first.Except<int>(second).ToList<int>(); }
private void GetReferences(JObject lockFile) { var target = GetTargetOrAttemptFallback(lockFile, needsRuntimeIdentifier: false); var frameworkReferences = new HashSet<string>(StringComparer.OrdinalIgnoreCase); var fileNamesOfRegularReferences = new HashSet<string>(StringComparer.OrdinalIgnoreCase); foreach (var package in target) { var packageNameParts = package.Key.Split('/'); var packageName = packageNameParts[0]; var packageVersion = packageNameParts[1]; Log.LogMessageFromResources(MessageImportance.Low, "ResolvedReferencesFromPackage", packageName); foreach (var referenceItem in CreateItems(packageName, packageVersion, package.Value, NuGetAssetTypeCompile)) { _references.Add(referenceItem); fileNamesOfRegularReferences.Add(Path.GetFileNameWithoutExtension(referenceItem.ItemSpec)); } if (IncludeFrameworkReferences) { var frameworkAssembliesArray = package.Value["frameworkAssemblies"] as JArray; if (frameworkAssembliesArray != null) { foreach (var frameworkAssembly in frameworkAssembliesArray.OfType<JToken>()) { frameworkReferences.Add((string)frameworkAssembly); } } } } foreach (var frameworkReference in frameworkReferences.Except(fileNamesOfRegularReferences, StringComparer.OrdinalIgnoreCase)) { _references.Add(new TaskItem(frameworkReference)); } }
public void Compare(TextWriter writer) { var newFiles = new HashSet<string>(Directory.GetFiles(newDir, "*.dbc").Select((file) => new FileInfo(file).Name), StringComparer.InvariantCultureIgnoreCase); var oldFiles = new HashSet<string>(Directory.GetFiles(oldDir, "*.dbc").Select((file) => new FileInfo(file).Name), StringComparer.InvariantCultureIgnoreCase); var addedFiles = newFiles.Except(oldFiles); var removedFiles = oldFiles.Except(newFiles); var existingFiles = newFiles.Except(addedFiles); if (addedFiles.Count() > 0) { writer.WriteLine("{0} files have been added:", addedFiles.Count()); foreach (var file in addedFiles) { writer.WriteLine("\t" + new FileInfo(file).Name); var reader = new DBCReader(Path.Combine(newDir, file)); writer.WriteLine("\t\tColumn Count: " + reader.ColumnCount); writer.WriteLine("\t\tRow Count: " + reader.RecordCount); writer.WriteLine("\t\tHas Strings: " + reader.HasStrings); if (reader.IrregularColumnSize) { writer.WriteLine("\t\tColumn Size IRREGULAR!"); } } } if (removedFiles.Count() > 0) { writer.WriteLine("{0} files have been deprecated (not present anymore):", removedFiles.Count()); foreach (var file in addedFiles) { writer.WriteLine("\t" + new FileInfo(file).Name); } } writer.WriteLine(); writer.WriteLine("#######################################"); writer.WriteLine("Changes in files{0}:", maxTestAmount != int.MaxValue ? " - Testing with first " + maxTestAmount + " rows" : ""); writer.WriteLine(); foreach (var file in existingFiles) { var comparer = new DBCFileComparer(Path.Combine(oldDir, file), Path.Combine(newDir, file), maxTestAmount, null); if (comparer.NewReader.IrregularColumnSize) { writer.WriteLine("Skipping {0} (IRREGULAR Column Size)", file); } else if (comparer.NewReader.ColumnCount != comparer.OldReader.ColumnCount && (comparer.NewReader.ColumnCount < 2 || comparer.OldReader.ColumnCount < 2)) { writer.WriteLine("Skipping {0} (Only 1 column or less)", file); } else { comparer.Compare(writer); } } }
public void UpdateNotifications(Domain.Entity.Mill.Pipe pipeSavingState) { if (isProperlyCreated) { //* What can happen at Save Pipe: (NRO - non required inspection operation) //* - pipe is new and have no previous state (to update: NROs from current size type(new)) if (initialPipeSizeTypeId == Guid.Empty) { ProcessPipeTestResults(pipeSavingState.PipeTestResult); ProcessNROForPipeSizeType(pipeSavingState.Type.Id, pipeSavingState, NROWhatToDo.Add); } //* - pipe is existing and pipe size type changed (to update: NROs from previous size type(remove), NROs from current size type(new)) else if(pipeSavingState.Type == null || initialPipeSizeTypeId != pipeSavingState.Type.Id) { //update notification for old size type IList<Guid> removeId = new List<Guid>(); foreach (TestResultInfo t in initialTestResultList) { removeId.Add(t.OperationId); } removeId.Distinct(); foreach (Guid id in removeId) { manager.UpdateUnits(id); } foreach (Guid id in manager.cache.EnumerateOperationsForSizeType(initialPipeSizeTypeId)) { manager.cache.RemoveUnits(id, ChooseUnit(manager.cache.GetMeasure(id))); UpdateNotification(id); } //update notification for new size type ProcessPipeTestResults(pipeSavingState.PipeTestResult); foreach (Guid id in manager.cache.EnumerateOperationsForSizeType(pipeSavingState.Type.Id)) { manager.cache.AddUnits(id, ChooseUnit(manager.cache.GetMeasure(id), pipeSavingState)); UpdateNotification(id); } } //* - pipe is existing and operations were edited (to update: NROs from current size type(track changes)) else if (initialPipeSizeTypeId == pipeSavingState.Type.Id) { HashSet<NROInfo> initialState = new HashSet<NROInfo>(); initialState.UnionWith(initialNROList); HashSet<NROInfo> savingState = new HashSet<NROInfo>(); savingState.UnionWith(GetNROInfoListFromPipeTestResultList(pipeSavingState.PipeTestResult)); var resultList = savingState.Except(initialState); foreach (NROInfo result in resultList.Distinct()) { if (result.IsCompleted) { manager.UpdateUnits(result.OperationId); } } ProcessNROForPipeSizeType(pipeSavingState.Type.Id, pipeSavingState, NROWhatToDo.EditOperations); } //* - pipe deactivation (to update: NRO (remove)) else if (!pipeSavingState.IsActive) { ProcessPipeTestResults(pipeSavingState.PipeTestResult); ProcessNROForPipeSizeType(pipeSavingState.Type.Id, pipeSavingState, NROWhatToDo.Remove); } } NotificationService.Instance.NotifyInterested(); SavePipeState(pipeSavingState); }